12350675235

Committed 16 Dec 2024 10:26AM UTC coverage: 90.135% (+0.04%) from 90.091%

Build # 12350675235

Build Type

Pull #2194

github

Committed by

jmealy

Commit Message

remove commented code

Pull Request Pull Request #2194: Allow targeting of all safes for outreach campaigns

Run Details

2821 of 3504 branches covered (80.51%)

Branch coverage included in aggregate %.

14 of 18 new or added lines in 5 files covered. (77.78%)

2 existing lines in 1 file now uncovered.

9632 of 10312 relevant lines covered (93.41%)

434.97 hits per line

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

92.21

/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,
  Injectable,
  UnprocessableEntityException,
} from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
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 getOutreach(outreachId: number): Promise<Outreach> {
    const [dbOutreach] = await this.sql<
      DbOutreach[]
    >`SELECT * FROM outreaches WHERE id = ${outreachId}`.catch((err) => {
      this.loggingService.warn(
        `Error getting outreach: ${asError(err).message}`,
      );
      throw new UnprocessableEntityException('Error getting outreach');
    });

    if (!dbOutreach) {
      throw new UnprocessableEntityException('Outreach not found');
    }

    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`.catch(
      (err) => {
        this.loggingService.warn(
          `Error getting unprocessed outreaches: ${asError(err).message}`,
        );
        throw new UnprocessableEntityException(
          'Error getting unprocessed outreaches',
        );
      },
    );

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

safe-global / safe-client-gateway / 12350675235

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