11476072473

Committed 23 Oct 2024 08:29AM UTC coverage: 90.247% (-0.04%) from 90.29%

Build # 11476072473

Build Type

Pull #2044

github

Committed by

hectorgomezv

Commit Message

Merge branch 'add-targeted-messagine-db-mappers' into add-outreach-file-processor-logging

Pull Request Pull Request #2044: Add OutreachFileProcessor logging

Run Details

2694 of 3298 branches covered (81.69%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

8974 of 9631 relevant lines covered (93.18%)

445.1 hits per line

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

94.03

/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/v1/cached-query-resolver';
import { ICachedQueryResolver } from '@/datasources/db/v1/cached-query-resolver.interface';
import { OutreachDbMapper } from '@/datasources/targeted-messaging/entities/outreach.db.mapper';
import { Outreach as DbOutreach } from '@/datasources/targeted-messaging/entities/outreach.entity';
import { SubmissionDbMapper } from '@/datasources/targeted-messaging/entities/submission.db.mapper';
import { Submission as DbSubmission } from '@/datasources/targeted-messaging/entities/submission.entity';
import { TargetedSafeDbMapper } from '@/datasources/targeted-messaging/entities/targeted-safe.db.mapper';
import { TargetedSafe as DbTargetedSafe } from '@/datasources/targeted-messaging/entities/targeted-safe.entity';
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 { UpdateOutreachDto } from '@/domain/targeted-messaging/entities/update-outreach.dto.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';

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,
    private readonly outreachDbMapper: OutreachDbMapper,
    private readonly submissionDbMapper: SubmissionDbMapper,
    private readonly targetedSafeDbMapper: TargetedSafeDbMapper,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
  }

  async createOutreach(
    createOutreachDto: CreateOutreachDto,
  ): Promise<Outreach> {
    const [dbOutreach] = 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 this.outreachDbMapper.map(dbOutreach);
  }

  async updateOutreach(
    updateOutreachDto: UpdateOutreachDto,
  ): Promise<Outreach> {
    const [dbOutreach] = 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 this.outreachDbMapper.map(dbOutreach);
  }

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

    return dbOutreaches.map((dbOutreach) =>
      this.outreachDbMapper.map(dbOutreach),
    );
  }

  async markOutreachAsProcessed(outreach: Outreach): Promise<Outreach> {
    const [updatedDbOutreach] = 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 this.outreachDbMapper.map(updatedDbOutreach);
  }

  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 dbTargetedSafes = await sql<
        DbTargetedSafe[]
      >`SELECT * FROM targeted_safes WHERE id = ANY(${inserted.map((i) => i.id)})`;

      return dbTargetedSafes.map((dbTargetedSafe) =>
        this.targetedSafeDbMapper.map(dbTargetedSafe),
      );
    });

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

    return targetedSafes;
  }

  async getTargetedSafe(args: {
    outreachId: number;
    safeAddress: `0x${string}`;
  }): Promise<TargetedSafe> {
    const [dbTargetedSafe] = 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 (!dbTargetedSafe) {
      throw new TargetedSafeNotFoundError();
    }

    return this.targetedSafeDbMapper.map(dbTargetedSafe);
  }

  async createSubmission(args: {
    targetedSafe: TargetedSafe;
    signerAddress: `0x${string}`;
  }): Promise<Submission> {
    const [dbSubmission] = 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 this.submissionDbMapper.map(dbSubmission, args.targetedSafe);
  }

  async getSubmission(args: {
    targetedSafe: TargetedSafe;
    signerAddress: `0x${string}`;
  }): Promise<Submission> {
    const [dbSubmission] = 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 (!dbSubmission) {
      throw new SubmissionNotFoundError();
    }

    return this.submissionDbMapper.map(dbSubmission, args.targetedSafe);
  }
}

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/v1/cached-query-resolver';	106✔
8	import { ICachedQueryResolver } from '@/datasources/db/v1/cached-query-resolver.interface';	106✔
9	import { OutreachDbMapper } from '@/datasources/targeted-messaging/entities/outreach.db.mapper';	106✔
10	import { Outreach as DbOutreach } from '@/datasources/targeted-messaging/entities/outreach.entity';
11	import { SubmissionDbMapper } from '@/datasources/targeted-messaging/entities/submission.db.mapper';	106✔
12	import { Submission as DbSubmission } from '@/datasources/targeted-messaging/entities/submission.entity';
13	import { TargetedSafeDbMapper } from '@/datasources/targeted-messaging/entities/targeted-safe.db.mapper';	106✔
14	import { TargetedSafe as DbTargetedSafe } from '@/datasources/targeted-messaging/entities/targeted-safe.entity';
15	import { ITargetedMessagingDatasource } from '@/domain/interfaces/targeted-messaging.datasource.interface';
16	import { CreateOutreachDto } from '@/domain/targeted-messaging/entities/create-outreach.dto.entity';
17	import { CreateTargetedSafesDto } from '@/domain/targeted-messaging/entities/create-targeted-safes.dto.entity';
18	import { Outreach } from '@/domain/targeted-messaging/entities/outreach.entity';
19	import { Submission } from '@/domain/targeted-messaging/entities/submission.entity';
20	import { TargetedSafe } from '@/domain/targeted-messaging/entities/targeted-safe.entity';
21	import { UpdateOutreachDto } from '@/domain/targeted-messaging/entities/update-outreach.dto.entity';
22	import { SubmissionNotFoundError } from '@/domain/targeted-messaging/errors/submission-not-found.error';	106✔
23	import { TargetedSafeNotFoundError } from '@/domain/targeted-messaging/errors/targeted-safe-not-found.error';	106✔
24	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	106✔
25	import { asError } from '@/logging/utils';	106✔
26	import { Inject, UnprocessableEntityException } from '@nestjs/common';	106✔
27	import postgres from 'postgres';	106✔
28
29	export class TargetedMessagingDatasource	106✔
30	implements ITargetedMessagingDatasource
31	{
32	private readonly defaultExpirationTimeInSeconds: number;
33
34	constructor(
35	@Inject(CacheService) private readonly cacheService: ICacheService,	4✔
36	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	4✔
37	@Inject(LoggingService) private readonly loggingService: ILoggingService,	4✔
38	@Inject(ICachedQueryResolver)
39	private readonly cachedQueryResolver: CachedQueryResolver,	4✔
40	@Inject(IConfigurationService)
41	private readonly configurationService: IConfigurationService,	4✔
42	private readonly outreachDbMapper: OutreachDbMapper,	4✔
43	private readonly submissionDbMapper: SubmissionDbMapper,	4✔
44	private readonly targetedSafeDbMapper: TargetedSafeDbMapper,	4✔
45	) {
46	this.defaultExpirationTimeInSeconds =	4✔
47	this.configurationService.getOrThrow<number>(
48	'expirationTimeInSeconds.default',
49	);
50	}
51
52	async createOutreach(
53	createOutreachDto: CreateOutreachDto,
54	): Promise<Outreach> {
55	const [dbOutreach] = await this.sql<DbOutreach[]>`	64✔
56	INSERT INTO outreaches (name, start_date, end_date, source_id, type, team_name, source_file, source_file_processed_date, source_file_checksum)
57	VALUES (
58	${createOutreachDto.name},
59	${createOutreachDto.startDate},
60	${createOutreachDto.endDate},
61	${createOutreachDto.sourceId},
62	${createOutreachDto.type},
63	${createOutreachDto.teamName},
64	${createOutreachDto.sourceFile},
65	${createOutreachDto.sourceFileProcessedDate},
66	${createOutreachDto.sourceFileChecksum}
67	)
68	RETURNING *`.catch((err) => {
69	this.loggingService.warn(	2✔
70	`Error creating outreach: ${asError(err).message}`,
71	);
72	throw new UnprocessableEntityException('Error creating outreach');	2✔
73	});
74
75	return this.outreachDbMapper.map(dbOutreach);	62✔
76	}
77
78	async updateOutreach(
79	updateOutreachDto: UpdateOutreachDto,
80	): Promise<Outreach> {
81	const [dbOutreach] = await this.sql<DbOutreach[]>`	10✔
82	UPDATE outreaches SET
83	name = ${updateOutreachDto.name},
84	start_date = ${updateOutreachDto.startDate},
85	end_date = ${updateOutreachDto.endDate},
86	type = ${updateOutreachDto.type},
87	team_name = ${updateOutreachDto.teamName}
88	WHERE source_id = ${updateOutreachDto.sourceId}
89	RETURNING *`.catch((err) => {
UNCOV 90	this.loggingService.warn(	×
91	`Error creating outreach: ${asError(err).message}`,
92	);
UNCOV 93	throw new UnprocessableEntityException('Error updating outreach');	×
94	});
95
96	return this.outreachDbMapper.map(dbOutreach);	10✔
97	}
98
99	async getUnprocessedOutreaches(): Promise<Outreach[]> {
100	const dbOutreaches = await this.sql<	30✔
101	DbOutreach[]
102	>`SELECT * FROM outreaches WHERE source_file_processed_date IS NULL`;
103
104	return dbOutreaches.map((dbOutreach) =>	30✔
105	this.outreachDbMapper.map(dbOutreach),	30✔
106	);
107	}
108
109	async markOutreachAsProcessed(outreach: Outreach): Promise<Outreach> {
110	const [updatedDbOutreach] = await this.sql<DbOutreach[]>`	8✔
111	UPDATE outreaches
112	SET source_file_processed_date = ${new Date()}
113	WHERE id = ${outreach.id}
114	RETURNING *`.catch((err) => {
UNCOV 115	this.loggingService.warn(	×
116	`Error marking outreach as processed: ${asError(err).message}`,
117	);
UNCOV 118	throw new UnprocessableEntityException(	×
119	'Error marking outreach as processed',
120	);
121	});
122
123	return this.outreachDbMapper.map(updatedDbOutreach);	8✔
124	}
125
126	async createTargetedSafes(
127	createTargetedSafesDto: CreateTargetedSafesDto,
128	): Promise<Array<TargetedSafe>> {
129	const targetedSafes = await this.sql.begin(async (sql) => {	40✔
130	const inserted = await sql<[{ id: number }]>`	40✔
131	INSERT INTO targeted_safes
132	${sql(
133	createTargetedSafesDto.addresses.map((address) => ({	364✔
134	outreach_id: createTargetedSafesDto.outreachId,
135	address,
136	})),
137	)}
138	RETURNING id`.catch((err) => {
139	this.loggingService.warn(	6✔
140	`Error adding targeted Safes: ${asError(err).message}`,
141	);
142	throw new UnprocessableEntityException('Error adding targeted Safes');	6✔
143	});
144
145	const dbTargetedSafes = await sql<	34✔
146	DbTargetedSafe[]
147	>`SELECT * FROM targeted_safes WHERE id = ANY(${inserted.map((i) => i.id)})`;	354✔
148
149	return dbTargetedSafes.map((dbTargetedSafe) =>	34✔
150	this.targetedSafeDbMapper.map(dbTargetedSafe),	354✔
151	);
152	});
153
154	await this.cacheService.deleteByKey(	34✔
155	CacheRouter.getTargetedSafeCacheKey(createTargetedSafesDto.outreachId),
156	);
157
158	return targetedSafes;	34✔
159	}
160
161	async getTargetedSafe(args: {
162	outreachId: number;
163	safeAddress: `0x${string}`;
164	}): Promise<TargetedSafe> {
165	const [dbTargetedSafe] = await this.cachedQueryResolver.get<	18✔
166	DbTargetedSafe[]
167	>({
168	cacheDir: CacheRouter.getTargetedSafeCacheDir(args),
169	query: this.sql`
170	SELECT * FROM targeted_safes
171	WHERE outreach_id = ${args.outreachId} AND address = ${args.safeAddress}`,
172	ttl: this.defaultExpirationTimeInSeconds,
173	});
174
175	if (!dbTargetedSafe) {	18✔
176	throw new TargetedSafeNotFoundError();	6✔
177	}
178
179	return this.targetedSafeDbMapper.map(dbTargetedSafe);	12✔
180	}
181
182	async createSubmission(args: {
183	targetedSafe: TargetedSafe;
184	signerAddress: `0x${string}`;
185	}): Promise<Submission> {
186	const [dbSubmission] = await this.sql<DbSubmission[]>`	10✔
187	INSERT INTO submissions (targeted_safe_id, signer_address, completion_date)
188	VALUES (${args.targetedSafe.id}, ${args.signerAddress}, ${new Date()})
189	RETURNING *`.catch((err) => {
190	this.loggingService.warn(	2✔
191	`Error creating submission: ${asError(err).message}`,
192	);
193	throw new UnprocessableEntityException('Error creating submission');	2✔
194	});
195	await this.cacheService.deleteByKey(	8✔
196	CacheRouter.getSubmissionCacheKey(args.targetedSafe.outreachId),
197	);
198
199	return this.submissionDbMapper.map(dbSubmission, args.targetedSafe);	8✔
200	}
201
202	async getSubmission(args: {
203	targetedSafe: TargetedSafe;
204	signerAddress: `0x${string}`;
205	}): Promise<Submission> {
206	const [dbSubmission] = await this.cachedQueryResolver.get<DbSubmission[]>({	12✔
207	cacheDir: CacheRouter.getSubmissionCacheDir({
208	outreachId: args.targetedSafe.outreachId,
209	safeAddress: args.targetedSafe.address,
210	signerAddress: args.signerAddress,
211	}),
212	query: this.sql`
213	SELECT * FROM submissions
214	WHERE targeted_safe_id = ${args.targetedSafe.id} AND signer_address = ${args.signerAddress}`,
215	ttl: this.defaultExpirationTimeInSeconds,
216	});
217
218	if (!dbSubmission) {	12✔
219	throw new SubmissionNotFoundError();	6✔
220	}
221
222	return this.submissionDbMapper.map(dbSubmission, args.targetedSafe);	6✔
223	}
224	}

safe-global / safe-client-gateway / 11476072473

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