SPIRIT-0: add preprocessor for db actions and add credentials logging for logged in use cases

Author: manuelfesantos

libs/db/generics/actions/types.ts

@@ -37,49 +37,65 @@ export type BaseMapperFunction<QueryFunction extends BaseQueryFunction> = (
   result: Awaited<ReturnType<QueryFunction>>,
 ) => unknown;
 
-export type QueryAction<Handler extends BaseQueryFunction> = (
-  ...params: Parameters<Handler>
-) => {
-  query: () => ReturnType<Handler>;
-  run: () => ReturnType<Handler>;
-};
-
-export type MappedAction<
-  Handler extends BaseQueryFunction,
-  Mapper extends BaseMapperFunction<Handler>,
-> = (...params: Parameters<Handler>) => {
-  run: () => Promise<ReturnType<Mapper>>;
-  query: () => ReturnType<Handler>;
-  map: Mapper;
-};
+export type BasePreProcessorFunction<QueryFunction extends BaseQueryFunction> =
+  (
+    ...args: any[]
+  ) => Parameters<QueryFunction> | Promise<Parameters<QueryFunction>>;
 
 export const actionBuilder = <
   Handler extends BaseQueryFunction,
+  PreProcessor extends
+    | BasePreProcessorFunction<Handler>
+    | undefined = undefined,
   Mapper extends BaseMapperFunction<Handler> | undefined = undefined,
 >(
   handler: Handler,
   mapper?: Mapper,
-): ((...params: Parameters<Handler>) => Action<Handler, Mapper>) => {
-  return (...params: Parameters<Handler>) => {
+  preProcessor?: PreProcessor,
+): ((
+  ...params: PreProcessor extends BasePreProcessorFunction<Handler>
+    ? Parameters<PreProcessor>
+    : Parameters<Handler>
+) => Action<Handler, Mapper, PreProcessor>) => {
+  return (...params) => {
     return {
-      query: (() => handler(...params)) as Handler,
-      run: (mapper
-        ? async () => mapper(await handler(...params))
-        : () => handler(...params)) as Action<Handler, Mapper>["run"],
+      params,
+      query: handler,
+      run: (async () => {
+        let handlerParams = params as
+          | (PreProcessor extends BasePreProcessorFunction<Handler>
+              ? Awaited<ReturnType<PreProcessor>>
+              : Parameters<Handler>)
+          | Parameters<Handler>;
+
+        if (preProcessor) {
+          handlerParams = await preProcessor(...params);
+        }
+        const queryResult = await handler(...handlerParams);
+        return mapper?.(queryResult) ?? queryResult;
+      }) as Action<Handler, Mapper, PreProcessor>["run"],
       map: mapper,
+      preProcess: preProcessor,
     };
   };
 };
 
 export type Action<
   Handler extends BaseQueryFunction,
   Mapper extends BaseMapperFunction<Handler> | undefined = undefined,
+  PreProcessor extends
+    | BasePreProcessorFunction<Handler>
+    | undefined = undefined,
 > = {
   query: Handler;
   run: Mapper extends BaseMapperFunction<Handler>
     ? () => Promise<ReturnType<Mapper>>
-    : () => ReturnType<Handler>;
+    : () => Promise<ReturnType<Handler>>;
   map?: Mapper;
+  preprocess?: PreProcessor;
+  params: PreProcessor extends BasePreProcessorFunction<Handler>
+    ? Parameters<PreProcessor>
+    : Parameters<Handler>;
 };
 
 export type Result<T extends (...args: any) => any> = Awaited<ReturnType<T>>;

libs/db/generics/operations/batch.ts

@@ -7,64 +7,72 @@ import {
   BaseMapperFunction,
   BaseQueryFunction,
   actionBuilder,
+  BasePreProcessorFunction,
 } from "../actions";
+import { BatchItem } from "drizzle-orm/batch";
 
 const NO_COUNT = 0;
 const FIRST_INDEX = 0;
 
 type BaseAction = Action<
   BaseQueryFunction,
-  BaseMapperFunction<BaseQueryFunction> | undefined
+  BaseMapperFunction<BaseQueryFunction> | undefined,
+  BasePreProcessorFunction<BaseQueryFunction> | undefined
 >;
 
-type ActionsType = NonEmptyArray<BaseAction>;
+type ActionsType = NonEmptyArray<BaseAction | undefined>;
 
-type BatchOperationResult<T extends ActionsType> = {
-  [K in keyof T]: T[K] extends { map?: infer M }
+type ActionFinalReturnType<Action extends BaseAction | undefined> =
+  Action extends {
+    map?: infer M;
+  }
     ? M extends BaseMapperFunction<BaseQueryFunction>
       ? Awaited<ReturnType<M>>
-      : Awaited<ReturnType<T[K]["query"]>>
-    : never;
+      : Awaited<ReturnType<Action["query"]>>
+    : undefined;
+
+type BatchOperationResult<Actions extends ActionsType> = {
+  [K in keyof Actions]: ActionFinalReturnType<Actions[K]>;
 };
 
-export const runBatchOperation = async <const Actions extends ActionsType>(
+export const runBatchOperation = async <Actions extends ActionsType>(
   ...actions: Actions
 ): Promise<BatchOperationResult<Actions>> => {
-  const queries = actions.map((action) => action.query()) as {
-    [K in keyof Actions]: ReturnType<Actions[K]["query"]>;
-  };
+  const params = await Promise.all(
+    actions.map(
+      async (action) =>
+        (await action?.preprocess?.(action.params)) ?? action?.params,
+    ),
+  );
+
+  const queries = actions
+    .map((action, index) => action?.query(params[index]))
+    .filter((action) => action !== undefined) as NonEmptyArray<
+    BatchItem<"sqlite">
+  >;
+
   if (!queries.length) {
     throw Error("No queries provided in batch operation");
   }
   const results = await db().batch(queries);
 
   const mappedResults = [];
+  let resultsIndex = 0;
 
   for (let i = 0; i < actions.length; i++) {
-    mappedResults[i] = (await actions[i].map?.(results[i])) ?? results[i];
+    if (actions[i] !== undefined) {
+      mappedResults[i] =
+        (await actions[i]?.map?.(results[resultsIndex])) ??
+        results[resultsIndex];
+      resultsIndex++;
+    } else {
+      mappedResults[i] = undefined;
+    }
   }
 
   return mappedResults as BatchOperationResult<Actions>;
 };
 
-export const createOperationBatch = <Actions extends ActionsType>(
-  ...args: Actions
-) => {
-  const operationBatch: Actions = [...args];
-  const addAction = <Action extends BaseAction>(action: Action) => {
-    operationBatch.push(action);
-  };
-  const run = async () => {
-    const results = await runBatchOperation(...operationBatch);
-    operationBatch.length = 0;
-    return results;
-  };
-  return {
-    addAction,
-    run,
-  };
-};
-
 const countQuery = <T extends TableConfig>(table: SQLiteTableWithColumns<T>) =>
   db().select({ count: count() }).from(table);
 

libs/db/user/actions/insert.ts

@@ -2,6 +2,7 @@ import { actionBuilder, Result } from "@generics-db";
 import { BaseUser, baseUserSchema, InsertUser } from "@user-entity";
 import { db } from "@db";
 import { usersTable } from "@schema";
+import { hashPassword } from "@crypto-utils";
 
 const insertUserQuery = (user: InsertUser) => {
   return db().insert(usersTable).values(user).returning();
@@ -17,7 +18,17 @@ const mapUserFromInsertResult = (
   return baseUserSchema.parse(firstResult);
 };
 
+const preProcessUserInsert = async (
+  user: InsertUser,
+): Promise<[user: InsertUser]> => {
+  if (user.password) {
+    user.password = await hashPassword(user.password, user.id);
+  }
+  return [user];
+};
+
 export const getInsertUserAction = actionBuilder(
   insertUserQuery,
   mapUserFromInsertResult,
+  preProcessUserInsert,
 );

libs/db/user/actions/update.ts

@@ -3,6 +3,7 @@ import { db } from "@db";
 import { usersTable } from "@schema";
 import { eq, sql } from "drizzle-orm";
 import { actionBuilder, Result } from "@generics-db";
+import { hashPassword } from "@crypto-utils";
 
 const ONE_VERSION = 1;
 
@@ -23,6 +24,16 @@ const mapUserFromUpdateQueryResult = (
   };
 };
 
+const preProcessUserUpdate = async (
+  userId: string,
+  changes: Partial<InsertUser>,
+): Promise<[userId: string, changes: Partial<InsertUser>]> => {
+  if (changes.password) {
+    changes.password = await hashPassword(changes.password, userId);
+  }
+  return [userId, changes];
+};
+
 const incrementUserVersionQuery = (userId: string) =>
   db()
     .update(usersTable)
@@ -42,6 +53,7 @@ const mapUserFromncrementVersionQueryResult = async (
 export const getUpdateUserAction = actionBuilder(
   updateUserQuery,
   mapUserFromUpdateQueryResult,
+  preProcessUserUpdate,
 );
 
 export const getIncrementUserVersionAction = actionBuilder(

libs/modules/currency/use-cases/get-all-currencies.ts

@@ -1,6 +1,6 @@
 import { Currency } from "@currency-entity";
 import { getSelectAllCurrenciesAction } from "@currency-db";
 
-export const getAllCurrencies = (): Promise<Currency[]> => {
-  return getSelectAllCurrenciesAction().run();
+export const getAllCurrencies = async (): Promise<Currency[]> => {
+  return await getSelectAllCurrenciesAction().run();
 };

libs/modules/order/use-cases/get-order-from-session-result.ts

@@ -33,7 +33,7 @@ import { sendEmail } from "@sendgrid-adapter";
 import { LoggerUseCaseEnum } from "@logger-entity";
 import { stringifyObject } from "@string-utils";
 import { getRandomUUID } from "@crypto-utils";
-import { createOperationBatch } from "@generics-db";
+import { runBatchOperation } from "@generics-db";
 import { withRetry } from "./payment/utils/retry-payment";
 
 export const getOrderFromSessionResult = async (
@@ -110,24 +110,15 @@ export const getOrderFromSessionResult = async (
     await getIncrementUserVersionAction(userId).run();
   }
 
-  const operationBatch = createOperationBatch(
+  const [, , [order]] = await runBatchOperation(
     insertShippingTransactionAction,
     insertOrderAction,
     selectOrdersByIdAction,
+    deleteCartAction,
+    insertCartAction,
+    updateUserAction,
   );
 
-  if (deleteCartAction) {
-    operationBatch.addAction(deleteCartAction);
-  }
-  if (insertCartAction) {
-    operationBatch.addAction(insertCartAction);
-  }
-  if (updateUserAction) {
-    operationBatch.addAction(updateUserAction);
-  }
-
-  const [, , [order]] = await operationBatch.run();
-
   if (!order) {
     throw new Error("Unable to create order");
   }

libs/modules/order/use-cases/payment/utils/retry-payment.ts

@@ -1,13 +1,13 @@
 const MAX_RETRIES = 3;
 const ONE_INCREMENT = 1;
 const MIN_RETRIES = 0;
-export const withRetry = async <T, K>(
+export const withRetry = <T, K>(
   args: T,
   callBack: (args: T) => Promise<K>,
   retries: number = MIN_RETRIES,
 ): Promise<K> => {
   try {
-    return await callBack(args);
+    return callBack(args);
   } catch (error) {
     if (retries < MAX_RETRIES) {
       return withRetry(args, callBack, retries + ONE_INCREMENT);

libs/modules/user/use-cases/details/get-user-details.ts

@@ -2,9 +2,13 @@ import { UserDetails } from "@user-entity";
 import { contextStore } from "@context-utils";
 import { decryptObjectString } from "@crypto-utils";
 import { getSelectUserDetailsByIdAction } from "@user-db";
+import { logCredentials } from "@logger-utils";
 
 export const getUserDetails = async (): Promise<UserDetails | undefined> => {
-  const { userDetails, userId } = contextStore.context;
+  const { userDetails, userId, cartId } = contextStore.context;
+
+  logCredentials(cartId, userId);
+
   if (userDetails) {
     return decryptObjectString<UserDetails>(userDetails);
   }

libs/modules/user/use-cases/details/handle-details-post.ts

@@ -1,6 +1,8 @@
 import { UserDetails, userDetailsSchema } from "@user-entity";
 import { encryptObject } from "@crypto-utils";
 import { requiredObjectSchema } from "@global-entity";
+import { contextStore } from "@context-utils";
+import { logCredentials } from "@logger-utils";
 
 const userDetailsPostPayloadSchema = requiredObjectSchema("Personal Details", {
   personalDetails: userDetailsSchema,
@@ -9,6 +11,10 @@ const userDetailsPostPayloadSchema = requiredObjectSchema("Personal Details", {
 export const handleDetailsPost = async (
   body: unknown,
 ): Promise<{ userDetails: UserDetails; encryptedUserDetails: string }> => {
+  const { userId, cartId } = contextStore.context;
+
+  logCredentials(cartId, userId);
+
   const { personalDetails } = userDetailsPostPayloadSchema.parse(body);
   const encryptedUserDetails = await encryptObject(personalDetails);
   return { userDetails: personalDetails, encryptedUserDetails };

libs/modules/user/use-cases/forgot-password/reset.ts

@@ -3,7 +3,7 @@ import { validateBaseSecret } from "@user-module";
 import { getSelectUserByEmailAction, getUpdateUserAction } from "@user-db";
 import { errors } from "@error-handling-utils";
 import { getLoggedInRefreshToken } from "@jwt-utils";
-import { hashPassword } from "@crypto-utils";
+import { logCredentials } from "@logger-utils";
 
 export const resetForgottenPassword = async (
   password: string,
@@ -12,9 +12,12 @@ export const resetForgottenPassword = async (
 ): Promise<void> => {
   const user = await getSelectUserByEmailAction(email).run();
   if (!user) throw errors.USER_NOT_FOUND();
+
+  logCredentials(user.cart?.id, user.id);
+
   await validateBaseSecret(email, code);
   await getUpdateUserAction(user.id, {
-    password: await hashPassword(password, user.id),
+    password,
   }).run();
   const userRefreshToken = await getLoggedInRefreshToken(user.id);
   await setAuthSecret(user.id, userRefreshToken);