refactor(core): custom phrase and log query factories (#2856)

packages/core/src/queries/custom-phrase.ts

@@ -1,17 +1,19 @@
 import type { CreateCustomPhrase, CustomPhrase } from '@logto/schemas';
 import { CustomPhrases } from '@logto/schemas';
 import { convertToIdentifiers, manyRows } from '@logto/shared';
+import type { CommonQueryMethods } from 'slonik';
 import { sql } from 'slonik';
 
-import { buildInsertInto } from '#src/database/insert-into.js';
+import { buildInsertIntoWithPool } from '#src/database/insert-into.js';
 import envSet from '#src/env-set/index.js';
 import { DeletionError } from '#src/errors/SlonikError/index.js';
 
 const { table, fields } = convertToIdentifiers(CustomPhrases);
 
-export const findAllCustomLanguageTags = async () => {
+export const createCustomPhraseQueries = (pool: CommonQueryMethods) => {
+  const findAllCustomLanguageTags = async () => {
     const rows = await manyRows<{ languageTag: string }>(
-    envSet.pool.query(sql`
+      pool.query(sql`
         select ${fields.languageTag}
         from ${table}
         order by ${fields.languageTag}
@@ -21,32 +23,35 @@ export const findAllCustomLanguageTags = async () => {
     return rows.map((row) => row.languageTag);
   };
 
-export const findAllCustomPhrases = async () =>
+  const findAllCustomPhrases = async () =>
     manyRows(
-    envSet.pool.query<CustomPhrase>(sql`
+      pool.query<CustomPhrase>(sql`
         select ${sql.join(Object.values(fields), sql`,`)}
         from ${table}
         order by ${fields.languageTag}
       `)
     );
 
-export const findCustomPhraseByLanguageTag = async (languageTag: string): Promise<CustomPhrase> =>
-  envSet.pool.one<CustomPhrase>(sql`
+  const findCustomPhraseByLanguageTag = async (languageTag: string): Promise<CustomPhrase> =>
+    pool.one<CustomPhrase>(sql`
       select ${sql.join(Object.values(fields), sql`, `)}
       from ${table}
       where ${fields.languageTag} = ${languageTag}
     `);
 
-export const upsertCustomPhrase = buildInsertInto<CreateCustomPhrase, CustomPhrase>(CustomPhrases, {
+  const upsertCustomPhrase = buildInsertIntoWithPool(pool)<CreateCustomPhrase, CustomPhrase>(
+    CustomPhrases,
+    {
       returning: true,
       onConflict: {
         fields: [fields.languageTag],
         setExcludedFields: [fields.translation],
       },
-});
+    }
+  );
 
-export const deleteCustomPhraseByLanguageTag = async (languageTag: string) => {
-  const { rowCount } = await envSet.pool.query(sql`
+  const deleteCustomPhraseByLanguageTag = async (languageTag: string) => {
+    const { rowCount } = await pool.query(sql`
       delete from ${table}
       where ${fields.languageTag}=${languageTag}
     `);
@@ -55,3 +60,21 @@ export const deleteCustomPhraseByLanguageTag = async (languageTag: string) => {
       throw new DeletionError(CustomPhrases.table, languageTag);
     }
   };
+
+  return {
+    findAllCustomLanguageTags,
+    findAllCustomPhrases,
+    findCustomPhraseByLanguageTag,
+    upsertCustomPhrase,
+    deleteCustomPhraseByLanguageTag,
+  };
+};
+
+/** @deprecated Will be removed soon. Use createCustomPhraseQueries() factory instead. */
+export const {
+  findAllCustomLanguageTags,
+  findAllCustomPhrases,
+  findCustomPhraseByLanguageTag,
+  upsertCustomPhrase,
+  deleteCustomPhraseByLanguageTag,
+} = createCustomPhraseQueries(envSet.pool);

packages/core/src/queries/log.ts

@@ -1,16 +1,15 @@
 import type { CreateLog, Log } from '@logto/schemas';
 import { token, Logs } from '@logto/schemas';
 import { conditionalSql, convertToIdentifiers } from '@logto/shared';
+import type { CommonQueryMethods } from 'slonik';
 import { sql } from 'slonik';
 
-import { buildFindEntityById } from '#src/database/find-entity-by-id.js';
-import { buildInsertInto } from '#src/database/insert-into.js';
+import { buildFindEntityByIdWithPool } from '#src/database/find-entity-by-id.js';
+import { buildInsertIntoWithPool } from '#src/database/insert-into.js';
 import envSet from '#src/env-set/index.js';
 
 const { table, fields } = convertToIdentifiers(Logs);
 
-export const insertLog = buildInsertInto<CreateLog>(Logs);
-
 export type LogCondition = {
   logKey?: string;
   applicationId?: string;
@@ -31,15 +30,18 @@ const buildLogConditionSql = (logCondition: LogCondition) =>
     return subConditions.length > 0 ? sql`where ${sql.join(subConditions, sql` and `)}` : sql``;
   });
 
-export const countLogs = async (condition: LogCondition) =>
-  envSet.pool.one<{ count: number }>(sql`
+export const createLogQueries = (pool: CommonQueryMethods) => {
+  const insertLog = buildInsertIntoWithPool(pool)<CreateLog>(Logs);
+
+  const countLogs = async (condition: LogCondition) =>
+    pool.one<{ count: number }>(sql`
       select count(*)
       from ${table}
       ${buildLogConditionSql(condition)}
     `);
 
-export const findLogs = async (limit: number, offset: number, logCondition: LogCondition) =>
-  envSet.pool.any<Log>(sql`
+  const findLogs = async (limit: number, offset: number, logCondition: LogCondition) =>
+    pool.any<Log>(sql`
       select ${sql.join(Object.values(fields), sql`,`)}
       from ${table}
       ${buildLogConditionSql(logCondition)}
@@ -48,13 +50,13 @@ export const findLogs = async (limit: number, offset: number, logCondition: LogC
       offset ${offset}
     `);
 
-export const findLogById = buildFindEntityById<CreateLog, Log>(Logs);
+  const findLogById = buildFindEntityByIdWithPool(pool)<CreateLog, Log>(Logs);
 
-export const getDailyActiveUserCountsByTimeInterval = async (
+  const getDailyActiveUserCountsByTimeInterval = async (
     startTimeExclusive: number,
     endTimeInclusive: number
   ) =>
-  envSet.pool.any<{ date: string; count: number }>(sql`
+    pool.any<{ date: string; count: number }>(sql`
       select date(${fields.createdAt}), count(distinct(${fields.payload}->>'userId'))
       from ${table}
       where ${fields.createdAt} > to_timestamp(${startTimeExclusive}::double precision / 1000)
@@ -64,11 +66,11 @@ export const getDailyActiveUserCountsByTimeInterval = async (
       group by date(${fields.createdAt})
     `);
 
-export const countActiveUsersByTimeInterval = async (
+  const countActiveUsersByTimeInterval = async (
     startTimeExclusive: number,
     endTimeInclusive: number
   ) =>
-  envSet.pool.one<{ count: number }>(sql`
+    pool.one<{ count: number }>(sql`
       select count(distinct(${fields.payload}->>'userId'))
       from ${table}
       where ${fields.createdAt} > to_timestamp(${startTimeExclusive}::double precision / 1000)
@@ -76,3 +78,23 @@ export const countActiveUsersByTimeInterval = async (
       and ${fields.key} like ${`${token.Type.ExchangeTokenBy}.%`}
       and ${fields.payload}->>'result' = 'Success'
     `);
+
+  return {
+    insertLog,
+    countLogs,
+    findLogs,
+    findLogById,
+    getDailyActiveUserCountsByTimeInterval,
+    countActiveUsersByTimeInterval,
+  };
+};
+
+/** @deprecated Will be removed soon. Use createLogQueries() factory instead. */
+export const {
+  insertLog,
+  countLogs,
+  findLogs,
+  findLogById,
+  getDailyActiveUserCountsByTimeInterval,
+  countActiveUsersByTimeInterval,
+} = createLogQueries(envSet.pool);