@baseplate-dev/fastify-generators 0.6.3 → 0.6.5

package/dist/generators/prisma/data-utils/templates/src/utils/data-operations/define-transformer.ts

@@ -0,0 +1,130 @@
+// @ts-nocheck
+
+import type {
+  AfterExecuteHook,
+  BoundTransformer,
+  MaybePromise,
+  Transformer,
+  TransformerResult,
+} from '$transformerTypes';
+import type { ServiceContext } from '%serviceContextImports';
+
+/**
+ * Configuration for `defineTransformer`.
+ *
+ * Provides a single `processInput` function that handles both create and update
+ * operations via a discriminated union on the `context` parameter.
+ *
+ * @template TInput - The input value type
+ * @template TCreateArgs - Tuple of additional create args
+ * @template TUpdateArgs - Tuple of additional update args
+ * @template TCreateOutput - Prisma data type for create operations
+ * @template TUpdateOutput - Prisma data type for update operations
+ */
+export interface DefineTransformerConfig<
+  TInput,
+  TCreateArgs extends unknown[],
+  TUpdateArgs extends unknown[],
+  TCreateOutput,
+  TUpdateOutput,
+> {
+  /**
+   * Process the input value for either a create or update operation.
+   *
+   * The `context` parameter is a discriminated union:
+   * - `{ type: 'create', args: TCreateArgs }` — creating a new record
+   * - `{ type: 'update', args: TUpdateArgs }` — updating an existing record
+   *
+   * Return `{ data: { create?, update? } }` with the Prisma-compatible data
+   * for each operation type, plus optional `afterExecute` hooks.
+   */
+  processInput(
+    value: TInput,
+    context:
+      | { type: 'create'; args: TCreateArgs }
+      | { type: 'update'; args: TUpdateArgs },
+    ctx: { serviceContext: ServiceContext },
+  ): MaybePromise<{
+    data?: { create?: TCreateOutput; update?: TUpdateOutput };
+    afterExecute?: AfterExecuteHook[];
+  }>;
+}
+
+/**
+ * Define a transformer from a single `processInput` function.
+ *
+ * This helper generates `forCreate(input, ...args)` and `forUpdate(input, ...args)`
+ * methods from one function that uses a discriminated union to distinguish operations.
+ *
+ * @example
+ * ```typescript
+ * const passwordTransformer = defineTransformer<string, [], [], string, string>({
+ *   async processInput(value) {
+ *     const hashed = await hash(value);
+ *     return { data: { create: hashed, update: hashed } };
+ *   },
+ * });
+ *
+ * // Usage:
+ * passwordTransformer.forCreate(password)
+ * passwordTransformer.forUpdate(password)
+ * ```
+ */
+export function defineTransformer<
+  TInput,
+  TCreateArgs extends unknown[],
+  TUpdateArgs extends unknown[],
+  TCreateOutput,
+  TUpdateOutput,
+>(
+  config: DefineTransformerConfig<
+    TInput,
+    TCreateArgs,
+    TUpdateArgs,
+    TCreateOutput,
+    TUpdateOutput
+  >,
+): Transformer<TInput, TCreateArgs, TUpdateArgs, TCreateOutput, TUpdateOutput> {
+  return {
+    forCreate(
+      input: TInput,
+      ...args: TCreateArgs
+    ): BoundTransformer<TCreateOutput> {
+      return {
+        async process(ctx): Promise<TransformerResult<TCreateOutput>> {
+          const result = await config.processInput(
+            input,
+            { type: 'create', args },
+            ctx,
+          );
+          return {
+            data: result.data?.create,
+            afterExecute: result.afterExecute,
+          };
+        },
+      };
+    },
+
+    forUpdate(
+      input: TInput | undefined,
+      ...args: TUpdateArgs
+    ): BoundTransformer<TUpdateOutput> {
+      return {
+        async process(ctx): Promise<TransformerResult<TUpdateOutput>> {
+          if (input === undefined) {
+            return {};
+          }
+          const result = await config.processInput(
+            input,
+            { type: 'update', args },
+            ctx,
+          );
+          return {
+            data: result.data?.update,
+            afterExecute: result.afterExecute,
+          };
+        },
+      };
+    },
+  };
+}

package/dist/generators/prisma/data-utils/templates/src/utils/data-operations/execute-transform-plan.ts

@@ -0,0 +1,108 @@
+// @ts-nocheck
+
+import type {
+  AnyBoundTransformer,
+  InferTransformed,
+  InferUnresolvedTransformed,
+  TransformPlan,
+} from '$transformerTypes';
+import type { Prisma } from '%prismaGeneratedImports';
+
+import { prisma } from '%prismaImports';
+
+/**
+ * Resolve any deferred data in the transformed map.
+ *
+ * Transformer data can be either a direct value or a deferred function
+ * `(tx) => Promise<value>`. This resolves all deferred values inside
+ * the transaction.
+ */
+async function resolveTransformed<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+>(
+  transformed: InferUnresolvedTransformed<TTransformers>,
+  tx: Prisma.TransactionClient,
+): Promise<InferTransformed<TTransformers>> {
+  const resolved: Record<string, unknown> = {};
+
+  for (const key of Object.keys(transformed)) {
+    const value = (transformed as Record<string, unknown>)[key];
+    resolved[key] =
+      typeof value === 'function'
+        ? await (value as (tx: Prisma.TransactionClient) => Promise<unknown>)(
+            tx,
+          )
+        : value;
+  }
+
+  return resolved as InferTransformed<TTransformers>;
+}
+
+/**
+ * Execute a transform plan inside a Prisma transaction.
+ *
+ * Resolves any deferred transformer data (functions that need `tx`),
+ * calls the `execute` callback with resolved data, then runs all
+ * `afterExecute` hooks collected from the transformers.
+ *
+ * If `refetch` is provided, calls it after the transaction with the
+ * result to reload the record with includes/relations. Cannot be used
+ * with `tx` since the parent transaction may not have committed yet.
+ *
+ * If `tx` is provided, reuses that transaction (for nested plans).
+ * Otherwise opens a new `$transaction`.
+ *
+ * @example
+ * ```typescript
+ * const result = await executeTransformPlan(plan, {
+ *   execute: async ({ tx, transformed }) =>
+ *     tx.todoList.create({ data: { ...rest, ...transformed } }),
+ *   refetch: (item) =>
+ *     prisma.todoList.findUniqueOrThrow({ where: { id: item.id }, ...query }),
+ * });
+ * ```
+ */
+export async function executeTransformPlan<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+  TResult,
+  TRefetchResult = TResult,
+>(
+  plan: TransformPlan<TTransformers>,
+  config: {
+    tx?: Prisma.TransactionClient;
+    execute: (args: {
+      tx: Prisma.TransactionClient;
+      transformed: InferTransformed<TTransformers>;
+    }) => Promise<TResult>;
+    refetch?: (result: TResult) => Promise<TRefetchResult>;
+  },
+): Promise<TResult | TRefetchResult> {
+  const { execute, refetch } = config;
+
+  if (config.tx && refetch) {
+    throw new Error(
+      'Cannot use refetch with an existing transaction — the parent transaction may not have committed yet.',
+    );
+  }
+
+  const runInTx = async (tx: Prisma.TransactionClient): Promise<TResult> => {
+    const resolved = await resolveTransformed(plan.transformed, tx);
+    const result = await execute({ tx, transformed: resolved });
+
+    for (const hook of plan.afterExecute) {
+      await hook({ tx, result });
+    }
+
+    return result;
+  };
+
+  const txResult = config.tx
+    ? await runInTx(config.tx)
+    : await prisma.$transaction(async (tx) => runInTx(tx));
+
+  if (refetch) {
+    return refetch(txResult);
+  }
+
+  return txResult;
+}

package/dist/generators/prisma/data-utils/templates/src/utils/data-operations/nested-transformers.ts

@@ -0,0 +1,364 @@
+// @ts-nocheck
+
+import type { GetResult, ModelPropName } from '$prismaTypes';
+import type {
+  BoundTransformer,
+  MaybePromise,
+  Transformer,
+  TransformerResult,
+} from '$transformerTypes';
+import type { Prisma } from '%prismaGeneratedImports';
+import type { ServiceContext } from '%serviceContextImports';
+import type { z } from 'zod';
+
+/**
+ * =========================================
+ * Shared Types
+ * =========================================
+ */
+
+/** Context passed to nested processCreate / processUpdate callbacks */
+interface NestedProcessContext {
+  serviceContext: ServiceContext;
+}
+
+/**
+ * A deferred operation returned by processCreate / processUpdate.
+ * Called inside the transaction after the parent record is created/updated.
+ *
+ * @template TParentResult - The type of the parent record
+ */
+type DeferredOperation<TParentResult> = (
+  tx: Prisma.TransactionClient,
+  parent: TParentResult,
+) => Promise<void>;
+
+/**
+ * =========================================
+ * One-to-One Transformer
+ * =========================================
+ */
+
+/**
+ * Configuration for a one-to-one nested transformer.
+ * Types are inferred from `parentModel`, `model`, and `schema`.
+ *
+ * @template TParentModelName - Prisma parent model name (for typing parent in deferred ops)
+ * @template TModelName - Prisma child model name (for typing existing)
+ * @template TInputSchema - Zod schema (for typing input)
+ */
+export interface OneToOneTransformerConfig<
+  TParentModelName extends ModelPropName,
+  TModelName extends ModelPropName,
+  TInputSchema extends z.ZodType,
+> {
+  /** Prisma parent model name — used for type inference only */
+  parentModel: TParentModelName;
+  /** Prisma child model name — used for type inference only */
+  model: TModelName;
+  /** Zod schema for the nested entity input — used for type inference only */
+  schema: TInputSchema;
+
+  /** Process a create operation. Returns a deferred operation for the transaction. */
+  processCreate: (
+    input: z.output<TInputSchema>,
+    ctx: NestedProcessContext,
+  ) => MaybePromise<DeferredOperation<GetResult<TParentModelName>>>;
+
+  /**
+   * Process an update operation. Only called when existing child is defined.
+   * If no existing child, `processCreate` is called instead.
+   * If omitted, updates are a no-op.
+   */
+  processUpdate?: (
+    input: z.output<TInputSchema>,
+    existing: GetResult<TModelName>,
+    ctx: NestedProcessContext,
+  ) => MaybePromise<DeferredOperation<GetResult<TParentModelName>>>;
+
+  /** Delete the nested entity. Called when input is `null` on update and existing is defined. */
+  processDelete: (
+    existing: GetResult<TModelName>,
+    ctx: NestedProcessContext,
+  ) => DeferredOperation<GetResult<TParentModelName>>;
+}
+
+/**
+ * Create a one-to-one nested transformer.
+ *
+ * Types are inferred from config — no manual generics needed:
+ * - `parent` in deferred ops is typed from `parentModel`
+ * - `existing` in processUpdate is typed from `model`
+ * - `input` in processCreate/processUpdate is typed from `schema`
+ *
+ * @example
+ * ```typescript
+ * const profileTransformer = oneToOneTransformer({
+ *   parentModel: 'user',
+ *   model: 'userProfile',
+ *   schema: profileInputSchema,
+ *   processCreate: (input, ctx) => async (tx, parent) => {
+ *     // parent is typed as GetResult<'user'>
+ *     // input is typed from profileInputSchema
+ *     await tx.userProfile.create({ data: { ...input, userId: parent.id } });
+ *   },
+ *   processUpdate: (input, existing, ctx) => async (tx, parent) => { ... },
+ *   processDelete: (existing) => async (tx, parent) => { ... },
+ * });
+ * ```
+ */
+export function oneToOneTransformer<
+  TParentModelName extends ModelPropName,
+  TModelName extends ModelPropName,
+  TInputSchema extends z.ZodType,
+>(
+  config: OneToOneTransformerConfig<TParentModelName, TModelName, TInputSchema>,
+): Transformer<
+  z.output<TInputSchema> | null | undefined,
+  [],
+  [
+    context: {
+      loadExisting: () => Promise<GetResult<TModelName> | null>;
+    },
+  ],
+  undefined,
+  undefined
+> {
+  return {
+    forCreate(
+      input: z.output<TInputSchema> | null | undefined,
+    ): BoundTransformer<undefined> {
+      return {
+        async process(ctx): Promise<TransformerResult<undefined>> {
+          if (input === null || input === undefined) return {};
+
+          const deferredOp = await config.processCreate(input, ctx);
+          return {
+            afterExecute: [
+              async ({ tx, result }) => {
+                await deferredOp(tx, result as GetResult<TParentModelName>);
+              },
+            ],
+          };
+        },
+      };
+    },
+
+    forUpdate(
+      input: z.output<TInputSchema> | null | undefined,
+      context: {
+        loadExisting: () => Promise<GetResult<TModelName> | null>;
+      },
+    ): BoundTransformer<undefined> {
+      return {
+        async process(ctx): Promise<TransformerResult<undefined>> {
+          if (input === undefined) return {};
+
+          const existing = (await context.loadExisting()) ?? undefined;
+
+          if (input === null) {
+            if (!existing) return {};
+            const deferredOp = config.processDelete(existing, ctx);
+            return {
+              afterExecute: [
+                async ({ tx, result }) => {
+                  await deferredOp(tx, result as GetResult<TParentModelName>);
+                },
+              ],
+            };
+          }
+
+          const deferredOp =
+            existing && config.processUpdate
+              ? await config.processUpdate(input, existing, ctx)
+              : await config.processCreate(input, ctx);
+          return {
+            afterExecute: [
+              async ({ tx, result }) => {
+                await deferredOp(tx, result as GetResult<TParentModelName>);
+              },
+            ],
+          };
+        },
+      };
+    },
+  };
+}
+
+/**
+ * =========================================
+ * One-to-Many Transformer
+ * =========================================
+ */
+
+/**
+ * Configuration for a one-to-many nested transformer.
+ * Types are inferred from `parentModel`, `model`, and `schema`.
+ *
+ * @template TParentModelName - Prisma parent model name
+ * @template TModelName - Prisma child model name
+ * @template TInputSchema - Zod schema for each item
+ */
+export interface OneToManyTransformerConfig<
+  TParentModelName extends ModelPropName,
+  TModelName extends ModelPropName,
+  TInputSchema extends z.ZodType,
+> {
+  /** Prisma parent model name — used for type inference only */
+  parentModel: TParentModelName;
+  /** Prisma child model name — used for type inference only */
+  model: TModelName;
+  /** Zod schema for each item's input — used for type inference only */
+  schema: TInputSchema;
+
+  /**
+   * Compare an input item to an existing item. Return true if they represent
+   * the same entity (e.g., matching IDs). If omitted, all items are treated
+   * as creates and all existing items are deleted (delete + recreate pattern).
+   */
+  compareItem?: (
+    input: z.output<TInputSchema>,
+    existing: GetResult<TModelName>,
+  ) => boolean;
+
+  /** Process a create operation for a single item. */
+  processCreate: (
+    itemInput: z.output<TInputSchema>,
+    ctx: NestedProcessContext,
+  ) => MaybePromise<DeferredOperation<GetResult<TParentModelName>>>;
+
+  /**
+   * Process an update operation for a single item.
+   * Only called when `compareItem` finds a match.
+   * If omitted, matched items fall through to `processCreate`.
+   */
+  processUpdate?: (
+    itemInput: z.output<TInputSchema>,
+    existingItem: GetResult<TModelName>,
+    ctx: NestedProcessContext,
+  ) => MaybePromise<DeferredOperation<GetResult<TParentModelName>>>;
+
+  /** Delete removed items not present in the input array. Called inside the transaction after the main operation. */
+  deleteRemoved: (
+    tx: Prisma.TransactionClient,
+    removedItems: GetResult<TModelName>[],
+    parent: GetResult<TParentModelName>,
+  ) => Promise<void>;
+}
+
+/**
+ * Create a one-to-many nested transformer.
+ *
+ * Types are inferred from config — no manual generics needed.
+ * Diff/match logic is provided by the caller via `loadExisting` in `.forUpdate()`.
+ *
+ * @example
+ * ```typescript
+ * const imagesTransformer = oneToManyTransformer({
+ *   parentModel: 'user',
+ *   model: 'userImage',
+ *   schema: imageInputSchema,
+ *   processCreate: (item, ctx) => async (tx, parent) => { ... },
+ *   processUpdate: (item, existing, ctx) => async (tx, parent) => { ... },
+ *   deleteRemoved: async (tx, removed, parent) => { ... },
+ * });
+ * ```
+ */
+export function oneToManyTransformer<
+  TParentModelName extends ModelPropName,
+  TModelName extends ModelPropName,
+  TInputSchema extends z.ZodType,
+>(
+  config: OneToManyTransformerConfig<
+    TParentModelName,
+    TModelName,
+    TInputSchema
+  >,
+): Transformer<
+  z.output<TInputSchema>[] | undefined,
+  [],
+  [
+    context: {
+      loadExisting: () => Promise<GetResult<TModelName>[]>;
+    },
+  ],
+  undefined,
+  undefined
+> {
+  return {
+    forCreate(
+      items: z.output<TInputSchema>[] | undefined,
+    ): BoundTransformer<undefined> {
+      return {
+        async process(ctx): Promise<TransformerResult<undefined>> {
+          if (!items || items.length === 0) return {};
+
+          const deferredOps = await Promise.all(
+            items.map(async (item) => config.processCreate(item, ctx)),
+          );
+
+          return {
+            afterExecute: [
+              async ({ tx, result }) => {
+                for (const op of deferredOps) {
+                  await op(tx, result as GetResult<TParentModelName>);
+                }
+              },
+            ],
+          };
+        },
+      };
+    },
+
+    forUpdate(
+      items: z.output<TInputSchema>[] | undefined,
+      context: {
+        loadExisting: () => Promise<GetResult<TModelName>[]>;
+      },
+    ): BoundTransformer<undefined> {
+      return {
+        async process(ctx): Promise<TransformerResult<undefined>> {
+          if (items === undefined) return {};
+
+          const existing = await context.loadExisting();
+
+          const { compareItem } = config;
+          const matched = items.map((item) => ({
+            item,
+            existingItem: compareItem
+              ? existing.find((e) => compareItem(item, e))
+              : undefined,
+          }));
+
+          const matchedExisting = new Set(
+            matched.map((m) => m.existingItem).filter(Boolean),
+          );
+          const removedItems = existing.filter((e) => !matchedExisting.has(e));
+
+          const deferredOps = await Promise.all(
+            matched.map(async ({ item, existingItem }) =>
+              existingItem && config.processUpdate
+                ? config.processUpdate(item, existingItem, ctx)
+                : config.processCreate(item, ctx),
+            ),
+          );
+
+          return {
+            afterExecute: [
+              async ({ tx, result }) => {
+                await config.deleteRemoved(
+                  tx,
+                  removedItems,
+                  result as GetResult<TParentModelName>,
+                );
+                for (const op of deferredOps) {
+                  await op(tx, result as GetResult<TParentModelName>);
+                }
+              },
+            ],
+          };
+        },
+      };
+    },
+  };
+}

package/dist/generators/prisma/data-utils/templates/src/utils/data-operations/prepare-transformers.ts

@@ -0,0 +1,73 @@
+// @ts-nocheck
+
+import type {
+  AfterExecuteHook,
+  AnyBoundTransformer,
+  InferUnresolvedTransformed,
+  TransformPlan,
+} from '$transformerTypes';
+import type { ServiceContext } from '%serviceContextImports';
+
+/**
+ * Configuration for `prepareTransformers`.
+ *
+ * @template TTransformers - Record of bound transformers (from `.forCreate()` / `.forUpdate()`)
+ */
+export interface PrepareTransformersConfig<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+> {
+  /** Bound transformers to process. Each should be the result of `.forCreate()` or `.forUpdate()`. */
+  transformers: TTransformers;
+  /** Service context with user info, request details, etc. */
+  serviceContext: ServiceContext;
+}
+
+/**
+ * Process all bound transformers and collect their results into a `TransformPlan`.
+ *
+ * Each bound transformer's `process` method is called to produce Prisma-compatible
+ * data and optional afterExecute hooks. The results are aggregated into a plan
+ * that can be passed to `executeTransformPlan`.
+ *
+ * @template TTransformers - Record of bound transformers
+ * @param config - Configuration with bound transformers and service context
+ * @returns A `TransformPlan` with resolved data and collected hooks
+ *
+ * @example
+ * ```typescript
+ * const plan = await prepareTransformers({
+ *   transformers: {
+ *     coverPhoto: coverPhotoTransformer.forCreate(coverPhoto),
+ *   },
+ *   serviceContext,
+ * });
+ * ```
+ */
+export async function prepareTransformers<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+>(
+  config: PrepareTransformersConfig<TTransformers>,
+): Promise<TransformPlan<TTransformers>> {
+  const { transformers, serviceContext } = config;
+
+  const entries = Object.entries(transformers);
+  const results = await Promise.all(
+    entries.map(async ([, boundTransformer]) =>
+      boundTransformer.process({ serviceContext }),
+    ),
+  );
+
+  const transformed = {} as InferUnresolvedTransformed<TTransformers>;
+  const afterExecute: AfterExecuteHook[] = [];
+
+  for (const [index, result] of results.entries()) {
+    const key = entries[index][0];
+    (transformed as Record<string, unknown>)[key] = result.data;
+
+    if (result.afterExecute) {
+      afterExecute.push(...result.afterExecute);
+    }
+  }
+
+  return { transformed, afterExecute };
+}