11407576032

Committed 18 Oct 2024 04:39PM UTC coverage: 91.581% (-0.2%) from 91.751%

Build # 11407576032

Build Type

Pull #2033

github

Committed by

hectorgomezv

Commit Message

Add AwsCloudStorageApiService

Pull Request Pull Request #2033: Parse Targeted Messaging data files

Run Details

2645 of 3205 branches covered (82.53%)

Branch coverage included in aggregate %.

76 of 105 new or added lines in 10 files covered. (72.38%)

3 existing lines in 1 file now uncovered.

8799 of 9291 relevant lines covered (94.7%)

429.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.14

/src/datasources/targeted-messaging/targeted-messaging.datasource.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';
import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';
import { ITargetedMessagingDatasource } from '@/domain/interfaces/targeted-messaging.datasource.interface';
import { CreateOutreachDto } from '@/domain/targeted-messaging/entities/create-outreach.dto.entity';
import { CreateTargetedSafesDto } from '@/domain/targeted-messaging/entities/create-targeted-safes.dto.entity';
import { Outreach } from '@/domain/targeted-messaging/entities/outreach.entity';
import { Submission } from '@/domain/targeted-messaging/entities/submission.entity';
import { TargetedSafe } from '@/domain/targeted-messaging/entities/targeted-safe.entity';
import { TargetedSafe as DbTargetedSafe } from '@/datasources/targeted-messaging/entities/targeted-safe.entity';
import { Submission as DbSubmission } from '@/datasources/targeted-messaging/entities/submission.entity';
import { Outreach as DbOutreach } from '@/datasources/targeted-messaging/entities/outreach.entity';
import { SubmissionNotFoundError } from '@/domain/targeted-messaging/errors/submission-not-found.error';
import { TargetedSafeNotFoundError } from '@/domain/targeted-messaging/errors/targeted-safe-not-found.error';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { asError } from '@/logging/utils';
import { Inject, UnprocessableEntityException } from '@nestjs/common';
import postgres from 'postgres';
import { UpdateOutreachDto } from '@/domain/targeted-messaging/entities/update-outreach.dto.entity';

export class TargetedMessagingDatasource
  implements ITargetedMessagingDatasource
{
  private readonly defaultExpirationTimeInSeconds: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject('DB_INSTANCE') private readonly sql: postgres.Sql,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(ICachedQueryResolver)
    private readonly cachedQueryResolver: CachedQueryResolver,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
  }

  async createOutreach(
    createOutreachDto: CreateOutreachDto,
  ): Promise<Outreach> {
    const [outreach] = await this.sql<DbOutreach[]>`
      INSERT INTO outreaches (name, start_date, end_date, source_id, type, team_name, source_file, source_file_processed_date, source_file_checksum)
      VALUES (
        ${createOutreachDto.name}, 
        ${createOutreachDto.startDate}, 
        ${createOutreachDto.endDate}, 
        ${createOutreachDto.sourceId}, 
        ${createOutreachDto.type}, 
        ${createOutreachDto.teamName},
        ${createOutreachDto.sourceFile},
        ${createOutreachDto.sourceFileProcessedDate},
        ${createOutreachDto.sourceFileChecksum}
        )
      RETURNING *`.catch((err) => {
      this.loggingService.warn(
        `Error creating outreach: ${asError(err).message}`,
      );
      throw new UnprocessableEntityException('Error creating outreach');
    });

    return {
      id: outreach.id,
      name: outreach.name,
      startDate: this.parseDate(outreach.start_date),
      endDate: this.parseDate(outreach.end_date),
      sourceId: outreach.source_id,
      type: outreach.type,
      teamName: outreach.team_name,
      sourceFile: outreach.source_file,
      sourceFileProcessedDate: outreach.source_file_processed_date
        ? this.parseDate(outreach.source_file_processed_date)
        : null,
      sourceFileChecksum: outreach.source_file_checksum,
      created_at: this.parseDate(outreach.created_at),
      updated_at: this.parseDate(outreach.updated_at),
    };
  }

  async updateOutreach(
    updateOutreachDto: UpdateOutreachDto,
  ): Promise<Outreach> {
    const [outreach] = await this.sql<DbOutreach[]>`
    UPDATE outreaches SET
      name = ${updateOutreachDto.name},
      start_date = ${updateOutreachDto.startDate},
      end_date = ${updateOutreachDto.endDate},
      type = ${updateOutreachDto.type},
      team_name = ${updateOutreachDto.teamName}
    WHERE source_id = ${updateOutreachDto.sourceId}
    RETURNING *`.catch((err) => {
      this.loggingService.warn(
        `Error creating outreach: ${asError(err).message}`,
      );
      throw new UnprocessableEntityException('Error updating outreach');
    });

    return {
      id: outreach.id,
      name: outreach.name,
      startDate: this.parseDate(outreach.start_date),
      endDate: this.parseDate(outreach.end_date),
      sourceId: outreach.source_id,
      type: outreach.type,
      teamName: outreach.team_name,
      sourceFile: outreach.source_file,
      sourceFileProcessedDate: outreach.source_file_processed_date
        ? this.parseDate(outreach.source_file_processed_date)
        : null,
      sourceFileChecksum: outreach.source_file_checksum,
      created_at: this.parseDate(outreach.created_at),
      updated_at: this.parseDate(outreach.updated_at),
    };
  }

  async getUnprocessedOutreaches(): Promise<Outreach[]> {
    const outreaches = await this.sql<
      DbOutreach[]
    >`SELECT * FROM outreaches WHERE source_file_processed_date IS NULL`;

    return outreaches.map((outreach) => ({
      id: outreach.id,
      name: outreach.name,
      startDate: this.parseDate(outreach.start_date),
      endDate: this.parseDate(outreach.end_date),
      sourceId: outreach.source_id,
      type: outreach.type,
      teamName: outreach.team_name,
      sourceFile: outreach.source_file,
      sourceFileProcessedDate: outreach.source_file_processed_date
        ? this.parseDate(outreach.source_file_processed_date)
        : null,
      sourceFileChecksum: outreach.source_file_checksum,
      created_at: this.parseDate(outreach.created_at),
      updated_at: this.parseDate(outreach.updated_at),
    }));
  }

  async markOutreachAsProcessed(outreach: Outreach): Promise<Outreach> {
    const [updatedOutreach] = await this.sql<DbOutreach[]>`
      UPDATE outreaches
      SET source_file_processed_date = ${new Date()}
      WHERE id = ${outreach.id}
      RETURNING *`.catch((err) => {
      this.loggingService.warn(
        `Error marking outreach as processed: ${asError(err).message}`,
      );
      throw new UnprocessableEntityException(
        'Error marking outreach as processed',
      );
    });

    return {
      id: updatedOutreach.id,
      name: updatedOutreach.name,
      startDate: this.parseDate(updatedOutreach.start_date),
      endDate: this.parseDate(updatedOutreach.end_date),
      sourceId: updatedOutreach.source_id,
      type: updatedOutreach.type,
      teamName: updatedOutreach.team_name,
      sourceFile: updatedOutreach.source_file,
      sourceFileProcessedDate: updatedOutreach.source_file_processed_date
        ? this.parseDate(updatedOutreach.source_file_processed_date)
        : null,
      sourceFileChecksum: updatedOutreach.source_file_checksum,
      created_at: this.parseDate(updatedOutreach.created_at),
      updated_at: this.parseDate(updatedOutreach.updated_at),
    };
  }

  async createTargetedSafes(
    createTargetedSafesDto: CreateTargetedSafesDto,
  ): Promise<Array<TargetedSafe>> {
    const targetedSafes = await this.sql.begin(async (sql) => {
      const inserted = await sql<[{ id: number }]>`
        INSERT INTO targeted_safes
        ${sql(
          createTargetedSafesDto.addresses.map((address) => ({
            outreach_id: createTargetedSafesDto.outreachId,
            address,
          })),
        )}
        RETURNING id`.catch((err) => {
        this.loggingService.warn(
          `Error adding targeted Safes: ${asError(err).message}`,
        );
        throw new UnprocessableEntityException('Error adding targeted Safes');
      });

      const targetedSafes = await sql<
        DbTargetedSafe[]
      >`SELECT * FROM targeted_safes WHERE id = ANY(${inserted.map((i) => i.id)})`;

      return targetedSafes.map((targetedSafe) => ({
        id: targetedSafe.id,
        outreachId: targetedSafe.outreach_id,
        address: targetedSafe.address,
        created_at: this.parseDate(targetedSafe.created_at),
        updated_at: this.parseDate(targetedSafe.updated_at),
      }));
    });

    await this.cacheService.deleteByKey(
      CacheRouter.getTargetedSafeCacheKey(createTargetedSafesDto.outreachId),
    );

    return targetedSafes;
  }

  async getTargetedSafe(args: {
    outreachId: number;
    safeAddress: `0x${string}`;
  }): Promise<TargetedSafe> {
    const [targetedSafe] = await this.cachedQueryResolver.get<DbTargetedSafe[]>(
      {
        cacheDir: CacheRouter.getTargetedSafeCacheDir(args),
        query: this.sql`
        SELECT * FROM targeted_safes
        WHERE outreach_id = ${args.outreachId} AND address = ${args.safeAddress}`,
        ttl: this.defaultExpirationTimeInSeconds,
      },
    );

    if (!targetedSafe) {
      throw new TargetedSafeNotFoundError();
    }

    return {
      id: targetedSafe.id,
      address: targetedSafe.address,
      outreachId: targetedSafe.outreach_id,
      created_at: this.parseDate(targetedSafe.created_at),
      updated_at: this.parseDate(targetedSafe.updated_at),
    };
  }

  async createSubmission(args: {
    targetedSafe: TargetedSafe;
    signerAddress: `0x${string}`;
  }): Promise<Submission> {
    const [submission] = await this.sql<DbSubmission[]>`
      INSERT INTO submissions (targeted_safe_id, signer_address, completion_date)
      VALUES (${args.targetedSafe.id}, ${args.signerAddress}, ${new Date()})
      RETURNING *`.catch((err) => {
      this.loggingService.warn(
        `Error creating submission: ${asError(err).message}`,
      );
      throw new UnprocessableEntityException('Error creating submission');
    });
    await this.cacheService.deleteByKey(
      CacheRouter.getSubmissionCacheKey(args.targetedSafe.outreachId),
    );

    return {
      id: submission.id,
      outreachId: args.targetedSafe.outreachId,
      targetedSafeId: submission.targeted_safe_id,
      signerAddress: submission.signer_address,
      completionDate: this.parseDate(submission.completion_date),
      created_at: this.parseDate(submission.created_at),
      updated_at: this.parseDate(submission.updated_at),
    };
  }

  async getSubmission(args: {
    targetedSafe: TargetedSafe;
    signerAddress: `0x${string}`;
  }): Promise<Submission> {
    const [submission] = await this.cachedQueryResolver.get<DbSubmission[]>({
      cacheDir: CacheRouter.getSubmissionCacheDir({
        outreachId: args.targetedSafe.outreachId,
        safeAddress: args.targetedSafe.address,
        signerAddress: args.signerAddress,
      }),
      query: this.sql`
        SELECT * FROM submissions
        WHERE targeted_safe_id = ${args.targetedSafe.id} AND signer_address = ${args.signerAddress}`,
      ttl: this.defaultExpirationTimeInSeconds,
    });

    if (!submission) {
      throw new SubmissionNotFoundError();
    }

    return {
      id: submission.id,
      outreachId: args.targetedSafe.outreachId,
      targetedSafeId: args.targetedSafe.id,
      signerAddress: args.signerAddress,
      completionDate: this.parseDate(submission.completion_date),
      created_at: this.parseDate(submission.created_at),
      updated_at: this.parseDate(submission.updated_at),
    };
  }

  private parseDate(date: Date | string): Date {
    return date instanceof Date ? date : new Date(date);
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	106✔
2	import { CacheRouter } from '@/datasources/cache/cache.router';	106✔
3	import {	106✔
4	CacheService,
5	ICacheService,
6	} from '@/datasources/cache/cache.service.interface';
7	import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';	106✔
8	import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';	106✔
9	import { ITargetedMessagingDatasource } from '@/domain/interfaces/targeted-messaging.datasource.interface';
10	import { CreateOutreachDto } from '@/domain/targeted-messaging/entities/create-outreach.dto.entity';
11	import { CreateTargetedSafesDto } from '@/domain/targeted-messaging/entities/create-targeted-safes.dto.entity';
12	import { Outreach } from '@/domain/targeted-messaging/entities/outreach.entity';
13	import { Submission } from '@/domain/targeted-messaging/entities/submission.entity';
14	import { TargetedSafe } from '@/domain/targeted-messaging/entities/targeted-safe.entity';
15	import { TargetedSafe as DbTargetedSafe } from '@/datasources/targeted-messaging/entities/targeted-safe.entity';
16	import { Submission as DbSubmission } from '@/datasources/targeted-messaging/entities/submission.entity';
17	import { Outreach as DbOutreach } from '@/datasources/targeted-messaging/entities/outreach.entity';
18	import { SubmissionNotFoundError } from '@/domain/targeted-messaging/errors/submission-not-found.error';	106✔
19	import { TargetedSafeNotFoundError } from '@/domain/targeted-messaging/errors/targeted-safe-not-found.error';	106✔
20	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	106✔
21	import { asError } from '@/logging/utils';	106✔
22	import { Inject, UnprocessableEntityException } from '@nestjs/common';	106✔
23	import postgres from 'postgres';	106✔
24	import { UpdateOutreachDto } from '@/domain/targeted-messaging/entities/update-outreach.dto.entity';
25
26	export class TargetedMessagingDatasource	106✔
27	implements ITargetedMessagingDatasource
28	{
29	private readonly defaultExpirationTimeInSeconds: number;
30
31	constructor(
32	@Inject(CacheService) private readonly cacheService: ICacheService,	4✔
33	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	4✔
34	@Inject(LoggingService) private readonly loggingService: ILoggingService,	4✔
35	@Inject(ICachedQueryResolver)
36	private readonly cachedQueryResolver: CachedQueryResolver,	4✔
37	@Inject(IConfigurationService)
38	private readonly configurationService: IConfigurationService,	4✔
39	) {
40	this.defaultExpirationTimeInSeconds =	4✔
41	this.configurationService.getOrThrow<number>(
42	'expirationTimeInSeconds.default',
43	);
44	}
45
46	async createOutreach(
47	createOutreachDto: CreateOutreachDto,
48	): Promise<Outreach> {
49	const [outreach] = await this.sql<DbOutreach[]>`	62✔
50	INSERT INTO outreaches (name, start_date, end_date, source_id, type, team_name, source_file, source_file_processed_date, source_file_checksum)
51	VALUES (
52	${createOutreachDto.name},
53	${createOutreachDto.startDate},
54	${createOutreachDto.endDate},
55	${createOutreachDto.sourceId},
56	${createOutreachDto.type},
57	${createOutreachDto.teamName},
58	${createOutreachDto.sourceFile},
59	${createOutreachDto.sourceFileProcessedDate},
60	${createOutreachDto.sourceFileChecksum}
61	)
62	RETURNING *`.catch((err) => {
63	this.loggingService.warn(	2✔
64	`Error creating outreach: ${asError(err).message}`,
65	);
66	throw new UnprocessableEntityException('Error creating outreach');	2✔
67	});
68
69	return {	60✔
70	id: outreach.id,
71	name: outreach.name,
72	startDate: this.parseDate(outreach.start_date),
73	endDate: this.parseDate(outreach.end_date),
74	sourceId: outreach.source_id,
75	type: outreach.type,
76	teamName: outreach.team_name,
77	sourceFile: outreach.source_file,
78	sourceFileProcessedDate: outreach.source_file_processed_date	30✔
79	? this.parseDate(outreach.source_file_processed_date)
80	: null,
81	sourceFileChecksum: outreach.source_file_checksum,
82	created_at: this.parseDate(outreach.created_at),
83	updated_at: this.parseDate(outreach.updated_at),
84	};
85	}
86
87	async updateOutreach(
88	updateOutreachDto: UpdateOutreachDto,
89	): Promise<Outreach> {
90	const [outreach] = await this.sql<DbOutreach[]>`	8✔
91	UPDATE outreaches SET
92	name = ${updateOutreachDto.name},
93	start_date = ${updateOutreachDto.startDate},
94	end_date = ${updateOutreachDto.endDate},
95	type = ${updateOutreachDto.type},
96	team_name = ${updateOutreachDto.teamName}
97	WHERE source_id = ${updateOutreachDto.sourceId}
98	RETURNING *`.catch((err) => {
NEW 99	this.loggingService.warn(	×
100	`Error creating outreach: ${asError(err).message}`,
101	);
NEW UNCOV 102	throw new UnprocessableEntityException('Error updating outreach');	×
103	});
104
105	return {	8✔
106	id: outreach.id,
107	name: outreach.name,
108	startDate: this.parseDate(outreach.start_date),
109	endDate: this.parseDate(outreach.end_date),
110	sourceId: outreach.source_id,
111	type: outreach.type,
112	teamName: outreach.team_name,
113	sourceFile: outreach.source_file,
114	sourceFileProcessedDate: outreach.source_file_processed_date	4!
115	? this.parseDate(outreach.source_file_processed_date)
116	: null,
117	sourceFileChecksum: outreach.source_file_checksum,
118	created_at: this.parseDate(outreach.created_at),
119	updated_at: this.parseDate(outreach.updated_at),
120	};
121	}
122
123	async getUnprocessedOutreaches(): Promise<Outreach[]> {
124	const outreaches = await this.sql<	28✔
125	DbOutreach[]
126	>`SELECT * FROM outreaches WHERE source_file_processed_date IS NULL`;
127
128	return outreaches.map((outreach) => ({	28✔
129	id: outreach.id,
130	name: outreach.name,
131	startDate: this.parseDate(outreach.start_date),
132	endDate: this.parseDate(outreach.end_date),
133	sourceId: outreach.source_id,
134	type: outreach.type,
135	teamName: outreach.team_name,
136	sourceFile: outreach.source_file,
137	sourceFileProcessedDate: outreach.source_file_processed_date	14!
138	? this.parseDate(outreach.source_file_processed_date)
139	: null,
140	sourceFileChecksum: outreach.source_file_checksum,
141	created_at: this.parseDate(outreach.created_at),
142	updated_at: this.parseDate(outreach.updated_at),
143	}));
144	}
145
146	async markOutreachAsProcessed(outreach: Outreach): Promise<Outreach> {
147	const [updatedOutreach] = await this.sql<DbOutreach[]>`	6✔
148	UPDATE outreaches
149	SET source_file_processed_date = ${new Date()}
150	WHERE id = ${outreach.id}
151	RETURNING *`.catch((err) => {
NEW UNCOV 152	this.loggingService.warn(	×
153	`Error marking outreach as processed: ${asError(err).message}`,
154	);
NEW UNCOV 155	throw new UnprocessableEntityException(	×
156	'Error marking outreach as processed',
157	);
158	});
159
160	return {	6✔
161	id: updatedOutreach.id,
162	name: updatedOutreach.name,
163	startDate: this.parseDate(updatedOutreach.start_date),
164	endDate: this.parseDate(updatedOutreach.end_date),
165	sourceId: updatedOutreach.source_id,
166	type: updatedOutreach.type,
167	teamName: updatedOutreach.team_name,
168	sourceFile: updatedOutreach.source_file,
169	sourceFileProcessedDate: updatedOutreach.source_file_processed_date	3!
170	? this.parseDate(updatedOutreach.source_file_processed_date)
171	: null,
172	sourceFileChecksum: updatedOutreach.source_file_checksum,
173	created_at: this.parseDate(updatedOutreach.created_at),
174	updated_at: this.parseDate(updatedOutreach.updated_at),
175	};
176	}
177
178	async createTargetedSafes(
179	createTargetedSafesDto: CreateTargetedSafesDto,
180	): Promise<Array<TargetedSafe>> {
181	const targetedSafes = await this.sql.begin(async (sql) => {	38✔
182	const inserted = await sql<[{ id: number }]>`	38✔
183	INSERT INTO targeted_safes
184	${sql(
185	createTargetedSafesDto.addresses.map((address) => ({	120✔
186	outreach_id: createTargetedSafesDto.outreachId,
187	address,
188	})),
189	)}
190	RETURNING id`.catch((err) => {
191	this.loggingService.warn(	6✔
192	`Error adding targeted Safes: ${asError(err).message}`,
193	);
194	throw new UnprocessableEntityException('Error adding targeted Safes');	6✔
195	});
196
197	const targetedSafes = await sql<	32✔
198	DbTargetedSafe[]
199	>`SELECT * FROM targeted_safes WHERE id = ANY(${inserted.map((i) => i.id)})`;	110✔
200
201	return targetedSafes.map((targetedSafe) => ({	110✔
202	id: targetedSafe.id,
203	outreachId: targetedSafe.outreach_id,
204	address: targetedSafe.address,
205	created_at: this.parseDate(targetedSafe.created_at),
206	updated_at: this.parseDate(targetedSafe.updated_at),
207	}));
208	});
209
210	await this.cacheService.deleteByKey(	32✔
211	CacheRouter.getTargetedSafeCacheKey(createTargetedSafesDto.outreachId),
212	);
213
214	return targetedSafes;	32✔
215	}
216
217	async getTargetedSafe(args: {
218	outreachId: number;
219	safeAddress: `0x${string}`;
220	}): Promise<TargetedSafe> {
221	const [targetedSafe] = await this.cachedQueryResolver.get<DbTargetedSafe[]>(	18✔
222	{
223	cacheDir: CacheRouter.getTargetedSafeCacheDir(args),
224	query: this.sql`
225	SELECT * FROM targeted_safes
226	WHERE outreach_id = ${args.outreachId} AND address = ${args.safeAddress}`,
227	ttl: this.defaultExpirationTimeInSeconds,
228	},
229	);
230
231	if (!targetedSafe) {	18✔
232	throw new TargetedSafeNotFoundError();	6✔
233	}
234
235	return {	12✔
236	id: targetedSafe.id,
237	address: targetedSafe.address,
238	outreachId: targetedSafe.outreach_id,
239	created_at: this.parseDate(targetedSafe.created_at),
240	updated_at: this.parseDate(targetedSafe.updated_at),
241	};
242	}
243
244	async createSubmission(args: {
245	targetedSafe: TargetedSafe;
246	signerAddress: `0x${string}`;
247	}): Promise<Submission> {
248	const [submission] = await this.sql<DbSubmission[]>`	10✔
249	INSERT INTO submissions (targeted_safe_id, signer_address, completion_date)
250	VALUES (${args.targetedSafe.id}, ${args.signerAddress}, ${new Date()})
251	RETURNING *`.catch((err) => {
252	this.loggingService.warn(	2✔
253	`Error creating submission: ${asError(err).message}`,
254	);
255	throw new UnprocessableEntityException('Error creating submission');	2✔
256	});
257	await this.cacheService.deleteByKey(	8✔
258	CacheRouter.getSubmissionCacheKey(args.targetedSafe.outreachId),
259	);
260
261	return {	8✔
262	id: submission.id,
263	outreachId: args.targetedSafe.outreachId,
264	targetedSafeId: submission.targeted_safe_id,
265	signerAddress: submission.signer_address,
266	completionDate: this.parseDate(submission.completion_date),
267	created_at: this.parseDate(submission.created_at),
268	updated_at: this.parseDate(submission.updated_at),
269	};
270	}
271
272	async getSubmission(args: {
273	targetedSafe: TargetedSafe;
274	signerAddress: `0x${string}`;
275	}): Promise<Submission> {
276	const [submission] = await this.cachedQueryResolver.get<DbSubmission[]>({	12✔
277	cacheDir: CacheRouter.getSubmissionCacheDir({
278	outreachId: args.targetedSafe.outreachId,
279	safeAddress: args.targetedSafe.address,
280	signerAddress: args.signerAddress,
281	}),
282	query: this.sql`
283	SELECT * FROM submissions
284	WHERE targeted_safe_id = ${args.targetedSafe.id} AND signer_address = ${args.signerAddress}`,
285	ttl: this.defaultExpirationTimeInSeconds,
286	});
287
288	if (!submission) {	12✔
289	throw new SubmissionNotFoundError();	6✔
290	}
291
292	return {	6✔
293	id: submission.id,
294	outreachId: args.targetedSafe.outreachId,
295	targetedSafeId: args.targetedSafe.id,
296	signerAddress: args.signerAddress,
297	completionDate: this.parseDate(submission.completion_date),
298	created_at: this.parseDate(submission.created_at),
299	updated_at: this.parseDate(submission.updated_at),
300	};
301	}
302
303	private parseDate(date: Date \| string): Date {
304	return date instanceof Date ? date : new Date(date);	706✔
305	}
306	}

safe-global / safe-client-gateway / 11407576032

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous