@baseplate-dev/fastify-generators 0.5.3 → 0.6.1

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

@@ -0,0 +1,366 @@
+// @ts-nocheck
+
+import type {
+  GetPayload,
+  ModelInclude,
+  ModelPropName,
+  WhereUniqueInput,
+} from '$prismaTypes';
+import type {
+  AnyFieldDefinition,
+  AnyOperationHooks,
+  CommitCreateConfig,
+  CommitDeleteConfig,
+  CommitUpdateConfig,
+  CreatePlan,
+  OperationContext,
+  TransactionalOperationContext,
+  UpdatePlan,
+} from '$types';
+
+import { invokeHooks } from '$fieldUtils';
+import { makeGenericPrismaDelegate } from '$prismaUtils';
+import { checkInstanceAuthorization } from '%authorizerUtilsImports';
+import { NotFoundError } from '%errorHandlerServiceImports';
+import { prisma } from '%prismaImports';
+
+/**
+ * Validate that query does not use `select` — only `include` is supported.
+ * Prisma `select` changes the return shape, which is incompatible with our
+ * typed return values and re-fetch logic.
+ */
+function validateQuery(query: unknown, operation: string): void {
+  if (query && typeof query === 'object') {
+    const unsupportedKeys = Object.entries(query)
+      .filter(([key, value]) => key !== 'include' && value !== undefined)
+      .map(([key]) => key);
+    if (unsupportedKeys.length > 0) {
+      throw new Error(
+        `Unsupported query keys for ${operation} operations: ${unsupportedKeys.join(', ')}. Only 'include' is supported.`,
+      );
+    }
+  }
+}
+
+/**
+ * Checks if any hooks are present that could modify data after the initial operation.
+ * Used to determine if a re-fetch is needed after operation completes.
+ */
+function hasPostExecuteHooks(hooks: AnyOperationHooks): boolean {
+  return (
+    (hooks.afterExecute?.length ?? 0) > 0 ||
+    (hooks.afterCommit?.length ?? 0) > 0
+  );
+}
+
+/**
+ * Re-fetch a record after hooks have run, ensuring included relations are fresh.
+ *
+ * Uses the caller's `refetchWithQuery` if provided, otherwise falls back to
+ * `makeGenericPrismaDelegate` with `{ id: result.id }`. Throws an explicit
+ * error if the result has no `id` field and no custom refetch was provided.
+ */
+async function refetchResult<
+  TModelName extends ModelPropName,
+  TIncludeArgs extends ModelInclude<TModelName>,
+>(
+  model: TModelName,
+  result: GetPayload<TModelName>,
+  query: TIncludeArgs,
+  refetchWithQuery?: (
+    result: GetPayload<TModelName>,
+    query: TIncludeArgs,
+  ) => Promise<GetPayload<TModelName, TIncludeArgs>>,
+): Promise<GetPayload<TModelName, TIncludeArgs>> {
+  if (refetchWithQuery) {
+    return refetchWithQuery(result, query);
+  }
+
+  const resultRecord = result as Record<string, unknown>;
+  if (!('id' in resultRecord) || !resultRecord.id) {
+    throw new Error(
+      `Cannot refetch ${model}: result has no 'id' field. Provide a custom refetchWithQuery.`,
+    );
+  }
+
+  const delegate = makeGenericPrismaDelegate(prisma, model);
+  const freshResult = await delegate.findUnique({
+    where: { id: resultRecord.id } as WhereUniqueInput<TModelName>,
+    include: query.include as NonNullable<ModelInclude<TModelName>['include']>,
+  });
+  if (!freshResult) {
+    throw new NotFoundError(`${model} not found after operation`);
+  }
+  return freshResult as GetPayload<TModelName, TIncludeArgs>;
+}
+
+/**
+ * Commit a create operation plan.
+ *
+ * Opens a Prisma transaction and executes the full lifecycle:
+ * 1. Validate query (no `select`)
+ * 2. Run beforeExecute hooks (inside transaction)
+ * 3. Call the execute callback with plan data
+ * 4. Run afterExecute hooks (inside transaction, with result)
+ * 5. Run afterCommit hooks (outside transaction, with result)
+ * 6. Re-fetch if hooks modified related records and query includes relations
+ */
+export async function commitCreate<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+>(
+  plan: CreatePlan<TModelName, TFields>,
+  config: CommitCreateConfig<TModelName, TFields, TIncludeArgs>,
+): Promise<GetPayload<TModelName, TIncludeArgs>> {
+  validateQuery(config.query, 'create');
+
+  const { execute } = config;
+  const needsRefetch = hasPostExecuteHooks(plan.hooks);
+
+  const baseOperationContext: OperationContext<
+    GetPayload<TModelName>,
+    { hasResult: false }
+  > = {
+    operation: 'create',
+    serviceContext: plan.serviceContext,
+    loadExisting: () => Promise.resolve(undefined),
+    result: undefined,
+  };
+
+  const transactionResult = await prisma.$transaction(async (tx) => {
+    const txContext: TransactionalOperationContext<
+      GetPayload<TModelName>,
+      { hasResult: false }
+    > = {
+      ...baseOperationContext,
+      tx,
+    };
+
+    // Run beforeExecute hooks
+    await invokeHooks(plan.hooks.beforeExecute, txContext);
+
+    // If re-fetching, don't include relations in initial create
+    const createQuery =
+      needsRefetch || !config.query
+        ? ({} as ModelInclude<TModelName>)
+        : (config.query as ModelInclude<TModelName>);
+
+    const result = await execute({
+      tx,
+      data: plan.data,
+      query: createQuery,
+      serviceContext: plan.serviceContext,
+    });
+
+    // Run afterExecute hooks
+    await invokeHooks(plan.hooks.afterExecute, {
+      ...txContext,
+      result,
+    });
+
+    return result;
+  });
+
+  // Run afterCommit hooks (outside transaction)
+  await invokeHooks(plan.hooks.afterCommit, {
+    ...baseOperationContext,
+    result: transactionResult,
+  });
+
+  // Re-fetch if hooks modified related records and query includes relations
+  if (needsRefetch && config.query?.include) {
+    return refetchResult(
+      plan.model,
+      transactionResult as GetPayload<TModelName>,
+      config.query,
+      config.refetchWithQuery,
+    );
+  }
+
+  return transactionResult as GetPayload<TModelName, TIncludeArgs>;
+}
+
+/**
+ * Commit an update operation plan.
+ *
+ * Opens a Prisma transaction and executes the full lifecycle:
+ * 1. Validate query (no `select`)
+ * 2. Run beforeExecute hooks (inside transaction)
+ * 3. Call the execute callback with plan data
+ * 4. Run afterExecute hooks (inside transaction, with result)
+ * 5. Run afterCommit hooks (outside transaction, with result)
+ * 6. Re-fetch if hooks modified related records and query includes relations
+ */
+export async function commitUpdate<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+>(
+  plan: UpdatePlan<TModelName, TFields>,
+  config: CommitUpdateConfig<TModelName, TFields, TIncludeArgs>,
+): Promise<GetPayload<TModelName, TIncludeArgs>> {
+  validateQuery(config.query, 'update');
+
+  const { execute } = config;
+  const needsRefetch = hasPostExecuteHooks(plan.hooks);
+
+  const baseOperationContext: OperationContext<
+    GetPayload<TModelName>,
+    { hasResult: false }
+  > = {
+    operation: 'update',
+    serviceContext: plan.serviceContext,
+    loadExisting: plan.loadExisting as () => Promise<
+      GetPayload<TModelName> | undefined
+    >,
+    result: undefined,
+  };
+
+  const transactionResult = await prisma.$transaction(async (tx) => {
+    const txContext: TransactionalOperationContext<
+      GetPayload<TModelName>,
+      { hasResult: false }
+    > = {
+      ...baseOperationContext,
+      tx,
+    };
+
+    // Run beforeExecute hooks
+    await invokeHooks(plan.hooks.beforeExecute, txContext);
+
+    // If re-fetching, don't include relations in initial update
+    const updateQuery =
+      needsRefetch || !config.query
+        ? ({} as ModelInclude<TModelName>)
+        : (config.query as ModelInclude<TModelName>);
+
+    const result = await execute({
+      tx,
+      data: plan.data,
+      query: updateQuery,
+      serviceContext: plan.serviceContext,
+    });
+
+    // Run afterExecute hooks
+    await invokeHooks(plan.hooks.afterExecute, {
+      ...txContext,
+      result,
+    });
+
+    return result;
+  });
+
+  // Run afterCommit hooks (outside transaction)
+  await invokeHooks(plan.hooks.afterCommit, {
+    ...baseOperationContext,
+    result: transactionResult,
+  });
+
+  // Re-fetch if hooks modified related records and query includes relations
+  if (needsRefetch && config.query?.include) {
+    return refetchResult(
+      plan.model,
+      transactionResult as GetPayload<TModelName>,
+      config.query,
+      config.refetchWithQuery,
+    );
+  }
+
+  return transactionResult as GetPayload<TModelName, TIncludeArgs>;
+}
+
+/**
+ * Execute a delete operation.
+ *
+ * No compose step is needed since there are no fields to process.
+ * Handles authorization, hooks, transaction, and execution directly.
+ *
+ * 1. Validate query (no `select`)
+ * 2. Run authorization checks (if configured)
+ * 3. Open transaction
+ * 4. Run beforeExecute hooks (inside transaction)
+ * 5. Call the execute callback
+ * 6. Run afterExecute hooks (inside transaction, with result)
+ * 7. Run afterCommit hooks (outside transaction, with result)
+ */
+export async function commitDelete<
+  TModelName extends ModelPropName,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+>(
+  config: CommitDeleteConfig<TModelName, TIncludeArgs>,
+): Promise<GetPayload<TModelName, TIncludeArgs>> {
+  validateQuery(config.query, 'delete');
+
+  const { context, execute, loadExisting: rawLoadExisting } = config;
+
+  // Memoize loadExisting if provided
+  let cached: GetPayload<TModelName> | undefined;
+  const loadExisting: () => Promise<GetPayload<TModelName> | undefined> =
+    rawLoadExisting
+      ? async () => {
+          cached ??= await rawLoadExisting();
+          return cached;
+        }
+      : () => Promise.resolve(undefined);
+
+  // Authorization
+  if (config.authorize && config.authorize.length > 0) {
+    await checkInstanceAuthorization(
+      context,
+      loadExisting as () => Promise<GetPayload<TModelName>>,
+      config.authorize,
+    );
+  }
+
+  const hooks: Required<AnyOperationHooks> = {
+    beforeExecute: [...(config.hooks?.beforeExecute ?? [])],
+    afterExecute: [...(config.hooks?.afterExecute ?? [])],
+    afterCommit: [...(config.hooks?.afterCommit ?? [])],
+  };
+
+  const baseOperationContext: OperationContext<
+    GetPayload<TModelName>,
+    { hasResult: false }
+  > = {
+    operation: 'delete',
+    serviceContext: context,
+    loadExisting,
+    result: undefined,
+  };
+
+  const transactionResult = await prisma.$transaction(async (tx) => {
+    const txContext: TransactionalOperationContext<
+      GetPayload<TModelName>,
+      { hasResult: false }
+    > = {
+      ...baseOperationContext,
+      tx,
+    };
+
+    // Run beforeExecute hooks
+    await invokeHooks(hooks.beforeExecute, txContext);
+
+    const result = await execute({
+      tx,
+      query: (config.query ?? {}) as ModelInclude<TModelName>,
+      serviceContext: context,
+    });
+
+    // Run afterExecute hooks
+    await invokeHooks(hooks.afterExecute, {
+      ...txContext,
+      result,
+    });
+
+    return result;
+  });
+
+  // Run afterCommit hooks (outside transaction)
+  await invokeHooks(hooks.afterCommit, {
+    ...baseOperationContext,
+    result: transactionResult,
+  });
+
+  return transactionResult as GetPayload<TModelName, TIncludeArgs>;
+}

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

@@ -0,0 +1,131 @@
+// @ts-nocheck
+
+import type { GetPayload, ModelPropName } from '$prismaTypes';
+import type {
+  AnyFieldDefinition,
+  AnyOperationHooks,
+  ComposeCreateConfig,
+  ComposeUpdateConfig,
+  InferInput,
+} from '$types';
+
+import { transformFields } from '$fieldUtils';
+import { CreatePlan, UpdatePlan } from '$types';
+import {
+  checkGlobalAuthorization,
+  checkInstanceAuthorization,
+} from '%authorizerUtilsImports';
+
+/**
+ * Compose a create operation plan.
+ *
+ * Processes field definitions via `transformFields`, collecting data transformations
+ * and hooks. Returns an immutable plan that can be transformed via `mapData` and
+ * `addHook` before committing.
+ *
+ * This is the pre-commit phase — field processing like `fileField` may do DB reads
+ * for validation, so this is not a pure function.
+ */
+export async function composeCreate<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+>(
+  config: ComposeCreateConfig<TModelName, TFields>,
+): Promise<CreatePlan<TModelName, TFields>> {
+  const { fields, input, context, authorize } = config;
+
+  // Authorization — fail fast before field processing
+  if (authorize && authorize.length > 0) {
+    checkGlobalAuthorization(context, authorize);
+  }
+
+  const { data: fieldsData, hooks: fieldsHooks } = await transformFields(
+    fields,
+    input,
+    {
+      operation: 'create',
+      serviceContext: context,
+      allowOptionalFields: false,
+      loadExisting: () => Promise.resolve(undefined),
+    },
+  );
+
+  const hooks: Required<AnyOperationHooks> = {
+    beforeExecute: [...(fieldsHooks.beforeExecute ?? [])],
+    afterExecute: [...(fieldsHooks.afterExecute ?? [])],
+    afterCommit: [...(fieldsHooks.afterCommit ?? [])],
+  };
+
+  return new CreatePlan({
+    model: config.model,
+    data: fieldsData.create,
+    hooks,
+    serviceContext: context,
+  });
+}
+
+/**
+ * Compose an update operation plan.
+ *
+ * Processes field definitions via `transformFields`, collecting data transformations
+ * and hooks. The caller provides a `loadExisting` function that controls how the
+ * existing item is fetched (e.g., with extra includes for authorization or diffing).
+ *
+ * Returns an immutable plan that can be transformed via `mapData` and `addHook`.
+ */
+export async function composeUpdate<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+>(
+  config: ComposeUpdateConfig<TModelName, TFields>,
+): Promise<UpdatePlan<TModelName, TFields>> {
+  const {
+    fields,
+    input,
+    context,
+    loadExisting: rawLoadExisting,
+    authorize,
+  } = config;
+
+  // Memoize loadExisting so multiple callers (authorization, field processing, developer inspection) share one fetch
+  let cached: GetPayload<TModelName> | undefined;
+  const loadExisting = async (): Promise<GetPayload<TModelName>> => {
+    cached ??= await rawLoadExisting();
+    return cached;
+  };
+
+  // Authorization — fail fast before field processing
+  if (authorize && authorize.length > 0) {
+    await checkInstanceAuthorization(context, loadExisting, authorize);
+  }
+
+  // Only transform fields present in input
+  const fieldsToTransform = Object.fromEntries(
+    Object.entries(fields).filter(([key]) => key in (input as object)),
+  ) as TFields;
+
+  const { data: fieldsData, hooks: fieldsHooks } = await transformFields(
+    fieldsToTransform,
+    input as InferInput<TFields>,
+    {
+      operation: 'update',
+      serviceContext: context,
+      allowOptionalFields: true,
+      loadExisting: loadExisting as () => Promise<Record<string, unknown>>,
+    },
+  );
+
+  const hooks: Required<AnyOperationHooks> = {
+    beforeExecute: [...(fieldsHooks.beforeExecute ?? [])],
+    afterExecute: [...(fieldsHooks.afterExecute ?? [])],
+    afterCommit: [...(fieldsHooks.afterCommit ?? [])],
+  };
+
+  return new UpdatePlan({
+    model: config.model,
+    data: fieldsData.update,
+    hooks,
+    serviceContext: context,
+    loadExisting,
+  });
+}

package/dist/generators/prisma/data-utils/templates/src/utils/data-operations/field-definitions.ts

@@ -25,7 +25,7 @@ import {
   generateCreateSchema,
   invokeHooks,
   transformFields,
-} from '$defineOperations';
+} from '$fieldUtils';
 import { makeGenericPrismaDelegate } from '$prismaUtils';
 import { prisma } from '%prismaImports';
 
@@ -37,7 +37,7 @@ import { prisma } from '%prismaImports';
  *
  * @template TSchema - The Zod schema type for validation
  * @param schema - Zod schema for validation
- * @returns Field definition
+ * @returns Scalar field definition that maps validated input directly to Prisma create/update data
  *
  * @example
  * ```typescript
@@ -213,15 +213,13 @@ export interface NestedOneToOneFieldConfig<
  *       avatar: fileField(avatarFileCategory),
  *     },
  *     getWhereUnique: (parent) => ({ userId: parent.id }),
- *     buildData: (data) => ({
- *       create: {
- *         bio: data.create.bio,
- *         avatar: data.create.avatar ? { connect: { id: data.create.avatar } } : undefined,
- *       },
- *       update: {
- *         bio: data.update.bio,
- *         avatar: data.update.avatar ? { connect: { id: data.update.avatar } } : undefined,
- *       },
+ *     buildCreateData: (data) => ({
+ *       bio: data.bio,
+ *       avatar: data.avatar ? { connect: { id: data.avatar } } : undefined,
+ *     }),
+ *     buildUpdateData: (data) => ({
+ *       bio: data.bio,
+ *       avatar: data.avatar ? { connect: { id: data.avatar } } : undefined,
  *     }),
  *   }),
  * };
@@ -315,8 +313,6 @@ export function nestedOneToOneField<
           ],
           afterExecute: [
             async (ctx) => {
-              const awaitedData =
-                typeof data === 'function' ? await data(ctx.tx) : data;
               const whereUnique = config.getWhereUnique(
                 ctx.result as GetPayload<TParentModelName>,
               );
@@ -331,7 +327,7 @@ export function nestedOneToOneField<
               const [builtCreate, builtUpdate] = await Promise.all([
                 config.buildCreateData(
                   {
-                    ...awaitedData.create,
+                    ...data.create,
                     ...({
                       [config.relationName]: { connect: parentWhereUnique },
                     } as Record<
@@ -343,7 +339,7 @@ export function nestedOneToOneField<
                   sharedCtx,
                 ),
                 config.buildUpdateData(
-                  awaitedData.update,
+                  data.update,
                   ctx.result as GetPayload<TParentModelName>,
                   sharedCtx,
                 ),
@@ -433,7 +429,8 @@ export interface NestedOneToManyFieldConfig<
 
   /**
    * Transform validated create field data into final Prisma structure for a single item.
-   * The returned payload should not include the parent relation field, as it will be added automatically.
+   * The parent relation connect is included in the data parameter. You can pass it
+   * through directly (e.g., `(data) => data`) or restructure as needed.
    */
   buildCreateData: (
     data: InferFieldsCreateOutput<TFields> &
@@ -502,6 +499,9 @@ function expandWhereUnique<TModelName extends ModelPropName>(
  * - **Delete**: Existing items not present in the input array are removed
  * - **No Change**: Passing `undefined` leaves the collection unchanged
  *
+ * **Important:** When a value is provided (not `undefined`), the input array is treated
+ * as the complete collection. Existing items not present in the array will be deleted.
+ *
  * All operations are performed atomically within the parent operation's transaction,
  * ensuring data consistency even if the operation fails.
  *
@@ -510,7 +510,7 @@ function expandWhereUnique<TModelName extends ModelPropName>(
  * @template TRelationName - Relation field name on child model
  * @template TFields - Field definitions for each child item
  * @param config - Configuration object for the one-to-many relationship
- * @returns Field definition for use in `defineCreateOperation` or `defineUpdateOperation`
+ * @returns Field definition for use with `composeCreate`/`composeUpdate` and `commitCreate`/`commitUpdate`
  *
  * @example
  * ```typescript
@@ -524,10 +524,8 @@ function expandWhereUnique<TModelName extends ModelPropName>(
  *       caption: scalarField(z.string()),
  *     },
  *     getWhereUnique: (input) => input.id ? { id: input.id } : undefined,
- *     buildData: (data) => ({
- *       create: { caption: data.caption },
- *       update: { caption: data.caption },
- *     }),
+ *     buildCreateData: (data) => ({ caption: data.caption }),
+ *     buildUpdateData: (data) => ({ caption: data.caption }),
  *   }),
  * };
  *
@@ -628,7 +626,7 @@ export function nestedOneToManyField<
       const processedItems = await Promise.all(
         value.map(async (itemInput, idx) => {
           const whereUnique =
-            existingModel && config.getWhereUnique(itemInput, existingModel);
+            existingModel && getWhereUnique(itemInput, existingModel);
 
           const { data, hooks } = await transformFields(
             config.fields,
@@ -697,11 +695,6 @@ export function nestedOneToManyField<
         // Upsert items
         await Promise.all(
           processedItems.map(async (item, idx) => {
-            const awaitedData =
-              typeof item.data === 'function'
-                ? await item.data(ctx.tx)
-                : item.data;
-
             const parentWhereUnique = config.parentModel.getWhereUnique(
               ctx.result,
             );
@@ -718,7 +711,7 @@ export function nestedOneToManyField<
             const [builtCreate, builtUpdate] = await Promise.all([
               config.buildCreateData(
                 {
-                  ...awaitedData.create,
+                  ...item.data.create,
                   ...({
                     [config.relationName]: { connect: parentWhereUnique },
                   } as Record<
@@ -729,12 +722,15 @@ export function nestedOneToManyField<
                 ctx.result,
                 sharedCtx,
               ),
-              config.buildUpdateData(awaitedData.update, ctx.result, sharedCtx),
+              config.buildUpdateData(item.data.update, ctx.result, sharedCtx),
             ]);
 
             results[idx] = item.whereUnique
               ? await prismaDelegate.upsert({
-                  where: item.whereUnique,
+                  where: {
+                    ...item.whereUnique,
+                    ...whereFromOriginalModel,
+                  } as WhereUniqueInput<TModelName>,
                   create: builtCreate,
                   update: builtUpdate,
                 })