@baseplate-dev/fastify-generators 0.5.0 → 0.5.2

package/dist/generators/prisma/data-utils/generated/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvC,CAAC"}

package/dist/generators/prisma/data-utils/generated/template-renderers.d.ts

@@ -29,6 +29,7 @@ export declare const PRISMA_DATA_UTILS_RENDERERS: {
             InternalServerError: {};
             logError: {};
             NotFoundError: {};
+            TooManyRequestsError: {};
             UnauthorizedError: {};
         }>>;
         paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").PrismaDataUtilsPaths>;

package/dist/generators/prisma/data-utils/generated/template-renderers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/template-renderers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAYzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAEnE,MAAM,WAAW,wBAAwB;IACvC,mBAAmB,EAAE;QACnB,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,2BAA2B,CAAC,mBAAmB,CACvD,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AAmDD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvC,CAAC"}
+{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/template-renderers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAYzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAEnE,MAAM,WAAW,wBAAwB;IACvC,mBAAmB,EAAE;QACnB,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,2BAA2B,CAAC,mBAAmB,CACvD,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AAmDD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvC,CAAC"}

package/dist/generators/prisma/data-utils/generated/typed-templates.d.ts

@@ -18,6 +18,7 @@ export declare const dataOperationsGroup: {
             InternalServerError: {};
             logError: {};
             NotFoundError: {};
+            TooManyRequestsError: {};
             UnauthorizedError: {};
         }>>;
         prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
@@ -106,6 +107,7 @@ export declare const PRISMA_DATA_UTILS_TEMPLATES: {
                 InternalServerError: {};
                 logError: {};
                 NotFoundError: {};
+                TooManyRequestsError: {};
                 UnauthorizedError: {};
             }>>;
             prismaGeneratedImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{

package/dist/generators/prisma/data-utils/generated/typed-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/typed-templates.ts"],"names":[],"mappings":"AAmJA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO/B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAC"}
+{"version":3,"file":"typed-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/data-utils/generated/typed-templates.ts"],"names":[],"mappings":"AAmJA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO/B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAC"}

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

@@ -66,6 +66,20 @@ export async function invokeHooks<TContext>(
   await Promise.all(hooks.map((hook) => hook(context)));
 }
 
+/**
+ * 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.
+ *
+ * @param hooks - The hooks object to check
+ * @returns true if afterExecute or afterCommit hooks exist
+ */
+function hasPostExecuteHooks(hooks: AnyOperationHooks): boolean {
+  return (
+    (hooks.afterExecute?.length ?? 0) > 0 ||
+    (hooks.afterCommit?.length ?? 0) > 0
+  );
+}
+
 type FieldDataOrFunction<TField extends AnyFieldDefinition> =
   | InferFieldOutput<TField>
   | ((tx: PrismaTransaction) => Promise<InferFieldOutput<TField>>);
@@ -333,6 +347,19 @@ export interface CreateOperationConfig<
    * Optional hooks for the operation
    */
   hooks?: OperationHooks<GetPayload<TModelName>>;
+
+  /**
+   * Function to extract unique identifier from the created result.
+   * Required for re-fetching fresh data after hooks modify related records.
+   *
+   * @example
+   * ```typescript
+   * getWhereUnique: (result) => ({ id: result.id })
+   * ```
+   */
+  getWhereUnique: (
+    result: GetPayload<TModelName>,
+  ) => WhereUniqueInput<TModelName>;
 }
 
 /**
@@ -488,49 +515,69 @@ export function defineCreateOperation<
       ],
     };
 
-    // Execute in transaction
-    return prisma
-      .$transaction(async (tx) => {
-        const txContext: TransactionalOperationContext<
-          GetPayload<TModelName>,
-          { hasResult: false }
-        > = {
-          ...baseOperationContext,
-          tx,
-        };
+    // Check if we need to re-fetch after hooks (hooks may modify related records)
+    const needsRefetch = hasPostExecuteHooks(allHooks);
 
-        // Run beforeExecute hooks
-        await invokeHooks(allHooks.beforeExecute, txContext);
+    // Execute in transaction
+    const transactionResult = await prisma.$transaction(async (tx) => {
+      const txContext: TransactionalOperationContext<
+        GetPayload<TModelName>,
+        { hasResult: false }
+      > = {
+        ...baseOperationContext,
+        tx,
+      };
+
+      // Run beforeExecute hooks
+      await invokeHooks(allHooks.beforeExecute, txContext);
+
+      // Run all async create data transformations
+      const awaitedFieldsData =
+        typeof fieldsData === 'function' ? await fieldsData(tx) : fieldsData;
+
+      // If re-fetching, don't include relations in initial create
+      const createQuery = needsRefetch
+        ? ({} as { include: NonNullable<TQueryArgs['include']> })
+        : ((query ?? {}) as { include: NonNullable<TQueryArgs['include']> });
+
+      const result = await config.create({
+        tx,
+        data: { ...awaitedFieldsData.create, ...preparedData },
+        query: createQuery,
+        serviceContext: context,
+      });
 
-        // Run all async create data transformations
-        const awaitedFieldsData =
-          typeof fieldsData === 'function' ? await fieldsData(tx) : fieldsData;
+      // Run afterExecute hooks
+      await invokeHooks(allHooks.afterExecute, {
+        ...txContext,
+        result,
+      });
 
-        const result = await config.create({
-          tx,
-          data: { ...awaitedFieldsData.create, ...preparedData },
-          query: (query ?? {}) as {
-            include: NonNullable<TQueryArgs['include']>;
-          },
-          serviceContext: context,
-        });
+      return result;
+    });
 
-        // Run afterExecute hooks
-        await invokeHooks(allHooks.afterExecute, {
-          ...txContext,
-          result,
-        });
+    // Run afterCommit hooks (outside transaction)
+    await invokeHooks(allHooks.afterCommit, {
+      ...baseOperationContext,
+      result: transactionResult,
+    });
 
-        return result;
-      })
-      .then(async (result) => {
-        // Run afterCommit hooks (outside transaction)
-        await invokeHooks(allHooks.afterCommit, {
-          ...baseOperationContext,
-          result,
-        });
-        return result as GetPayload<TModelName, TQueryArgs>;
+    // Re-fetch if hooks existed and query includes relations
+    if (needsRefetch && query?.include) {
+      const delegate = makeGenericPrismaDelegate(prisma, config.model);
+      const freshResult = await delegate.findUnique<TQueryArgs>({
+        where: config.getWhereUnique(
+          transactionResult as unknown as GetPayload<TModelName>,
+        ),
+        include: query.include,
       });
+      if (!freshResult) {
+        throw new NotFoundError(`${config.model} not found after create`);
+      }
+      return freshResult as GetPayload<TModelName, TQueryArgs>;
+    }
+
+    return transactionResult as GetPayload<TModelName, TQueryArgs>;
   };
   createOperation.$dataSchema = dataSchema;
   return createOperation;
@@ -809,50 +856,67 @@ export function defineUpdateOperation<
       ],
     };
 
-    // Execute in transaction
-    return prisma
-      .$transaction(async (tx) => {
-        const txContext: TransactionalOperationContext<
-          GetPayload<TModelName>,
-          { hasResult: false }
-        > = {
-          ...baseOperationContext,
-          tx,
-        };
+    // Check if we need to re-fetch after hooks (hooks may modify related records)
+    const needsRefetch = hasPostExecuteHooks(allHooks);
 
-        // Run beforeExecute hooks
-        await invokeHooks(allHooks.beforeExecute, txContext);
+    // Execute in transaction
+    const transactionResult = await prisma.$transaction(async (tx) => {
+      const txContext: TransactionalOperationContext<
+        GetPayload<TModelName>,
+        { hasResult: false }
+      > = {
+        ...baseOperationContext,
+        tx,
+      };
+
+      // Run beforeExecute hooks
+      await invokeHooks(allHooks.beforeExecute, txContext);
+
+      // Run all async update data transformations
+      const awaitedFieldsData =
+        typeof fieldsData === 'function' ? await fieldsData(tx) : fieldsData;
+
+      // If re-fetching, don't bother including relations in initial update
+      const updateQuery = needsRefetch
+        ? ({} as { include: NonNullable<TQueryArgs['include']> })
+        : ((query ?? {}) as { include: NonNullable<TQueryArgs['include']> });
+
+      const result = await config.update({
+        tx,
+        where,
+        data: { ...awaitedFieldsData.update, ...preparedData },
+        query: updateQuery,
+        serviceContext: context,
+      });
 
-        // Run all async update data transformations
-        const awaitedFieldsData =
-          typeof fieldsData === 'function' ? await fieldsData(tx) : fieldsData;
+      // Run afterExecute hooks
+      await invokeHooks(allHooks.afterExecute, {
+        ...txContext,
+        result,
+      });
 
-        const result = await config.update({
-          tx,
-          where,
-          data: { ...awaitedFieldsData.update, ...preparedData },
-          query: (query ?? {}) as {
-            include: NonNullable<TQueryArgs['include']>;
-          },
-          serviceContext: context,
-        });
+      return result;
+    });
 
-        // Run afterExecute hooks
-        await invokeHooks(allHooks.afterExecute, {
-          ...txContext,
-          result,
-        });
+    // Run afterCommit hooks (outside transaction)
+    await invokeHooks(allHooks.afterCommit, {
+      ...baseOperationContext,
+      result: transactionResult,
+    });
 
-        return result;
-      })
-      .then(async (result) => {
-        // Run afterCommit hooks (outside transaction)
-        await invokeHooks(allHooks.afterCommit, {
-          ...baseOperationContext,
-          result,
-        });
-        return result as GetPayload<TModelName, TQueryArgs>;
+    // Re-fetch if hooks existed and query includes relations
+    if (needsRefetch && query?.include) {
+      const freshResult = await delegate.findUnique<TQueryArgs>({
+        where,
+        include: query.include,
       });
+      if (!freshResult) {
+        throw new NotFoundError(`${config.model} not found after update`);
+      }
+      return freshResult as GetPayload<TModelName, TQueryArgs>;
+    }
+
+    return transactionResult as GetPayload<TModelName, TQueryArgs>;
   };
   updateOperation.$dataSchema = generateCreateSchema(config.fields).partial();
   return updateOperation;

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

@@ -30,64 +30,32 @@ import { makeGenericPrismaDelegate } from '$prismaUtils';
 import { prisma } from '%prismaImports';
 
 /**
- * Create a simple scalar field with validation and optional transformation
+ * Create a simple scalar field with validation
  *
  * This helper creates a field definition that validates input using a Zod schema.
- * Optionally, you can provide a transform function to convert the validated value
- * into a different type for Prisma operations.
- *
- * For relation fields (e.g., `userId`), use this helper to validate the ID,
- * then use relation helpers in the transform step to create Prisma connect/disconnect objects.
+ * The validated value is used directly for both create and update operations.
  *
  * @template TSchema - The Zod schema type for validation
- * @template TTransformed - The output type after transformation (defaults to schema output)
  * @param schema - Zod schema for validation
- * @param options - Optional configuration
- * @param options.transform - Function to transform the validated value
  * @returns Field definition
  *
  * @example
  * ```typescript
- * // Simple validation
  * const fields = {
  *   title: scalarField(z.string()),
- *   ownerId: scalarField(z.string()), // Validated as string
- * };
- *
- * // With transformation
- * const fields = {
- *   email: scalarField(
- *     z.email(),
- *     { transform: (email) => email.toLowerCase() }
- *   ),
- *   createdAt: scalarField(
- *     z.string().datetime(),
- *     { transform: (dateStr) => new Date(dateStr) }
- *   ),
+ *   email: scalarField(z.string().email()),
+ *   age: scalarField(z.number().int().positive()),
  * };
  * ```
  */
-export function scalarField<
-  TSchema extends z.ZodType,
-  TTransformed = z.output<TSchema>,
->(
+export function scalarField<TSchema extends z.ZodType>(
   schema: TSchema,
-  options?: {
-    transform?: (value: z.output<TSchema>) => TTransformed;
-  },
-): FieldDefinition<TSchema, TTransformed, TTransformed> {
+): FieldDefinition<TSchema, z.output<TSchema>, z.output<TSchema>> {
   return {
     schema,
-    processInput: (value) => {
-      // Apply transform if provided
-      const transformed = options?.transform
-        ? options.transform(value)
-        : (value as TTransformed);
-
-      return {
-        data: { create: transformed, update: transformed },
-      };
-    },
+    processInput: (value) => ({
+      data: { create: value, update: value },
+    }),
   };
 }
 
@@ -145,11 +113,6 @@ type RelationName<TModelName extends ModelPropName> = keyof Payload<
   (typeof prisma)[TModelName]
 >['objects'];
 
-interface PrismaFieldData<TModelName extends ModelPropName> {
-  create: CreateInput<TModelName>;
-  update: UpdateInput<TModelName>;
-}
-
 /**
  * Configuration for defining a nested one-to-one relationship field.
  *
@@ -196,20 +159,29 @@ export interface NestedOneToOneFieldConfig<
   ) => WhereUniqueInput<TModelName>;
 
   /**
-   * Transform validated field data into final Prisma structure
+   * Transform validated create field data into final Prisma structure
    */
-  buildData: (
-    data: {
-      create: InferFieldsCreateOutput<TFields> &
-        Record<TRelationName, { connect: WhereUniqueInput<TParentModelName> }>;
-      update: InferFieldsUpdateOutput<TFields>;
-    },
+  buildCreateData: (
+    data: InferFieldsCreateOutput<TFields> &
+      Record<TRelationName, { connect: WhereUniqueInput<TParentModelName> }>,
     parentModel: GetPayload<TParentModelName>,
     ctx: TransactionalOperationContext<
       GetPayload<TModelName>,
       { hasResult: false }
     >,
-  ) => PrismaFieldData<TModelName> | Promise<PrismaFieldData<TModelName>>;
+  ) => CreateInput<TModelName> | Promise<CreateInput<TModelName>>;
+
+  /**
+   * Transform validated update field data into final Prisma structure
+   */
+  buildUpdateData: (
+    data: InferFieldsUpdateOutput<TFields>,
+    parentModel: GetPayload<TParentModelName>,
+    ctx: TransactionalOperationContext<
+      GetPayload<TModelName>,
+      { hasResult: false }
+    >,
+  ) => UpdateInput<TModelName> | Promise<UpdateInput<TModelName>>;
 }
 
 /**
@@ -319,9 +291,9 @@ export function nestedOneToOneField<
         );
         const prismaDelegate = makeGenericPrismaDelegate(prisma, config.model);
         cachedExisting =
-          (await prismaDelegate.findUnique({
+          ((await prismaDelegate.findUnique({
             where: whereUnique,
-          })) ?? undefined;
+          })) as GetPayload<TModelName> | null) ?? undefined;
         return cachedExisting;
       }
 
@@ -351,9 +323,14 @@ export function nestedOneToOneField<
               const parentWhereUnique = config.parentModel.getWhereUnique(
                 ctx.result as GetPayload<TParentModelName>,
               );
-              const builtData = await config.buildData(
-                {
-                  create: {
+              const sharedCtx = {
+                ...ctx,
+                operation: 'upsert' as const,
+                loadExisting,
+              };
+              const [builtCreate, builtUpdate] = await Promise.all([
+                config.buildCreateData(
+                  {
                     ...awaitedData.create,
                     ...({
                       [config.relationName]: { connect: parentWhereUnique },
@@ -362,15 +339,15 @@ export function nestedOneToOneField<
                       { connect: WhereUniqueInput<TParentModelName> }
                     >),
                   },
-                  update: awaitedData.update,
-                },
-                ctx.result as GetPayload<TParentModelName>,
-                {
-                  ...ctx,
-                  operation: 'upsert',
-                  loadExisting,
-                },
-              );
+                  ctx.result as GetPayload<TParentModelName>,
+                  sharedCtx,
+                ),
+                config.buildUpdateData(
+                  awaitedData.update,
+                  ctx.result as GetPayload<TParentModelName>,
+                  sharedCtx,
+                ),
+              ]);
               const prismaDelegate = makeGenericPrismaDelegate(
                 ctx.tx,
                 config.model,
@@ -378,8 +355,8 @@ export function nestedOneToOneField<
 
               newModelResult = await prismaDelegate.upsert({
                 where: whereUnique,
-                create: builtData.create,
-                update: builtData.update,
+                create: builtCreate,
+                update: builtUpdate,
               });
 
               await invokeHooks(hooks.afterExecute, {
@@ -455,29 +432,30 @@ export interface NestedOneToManyFieldConfig<
   ) => WhereUniqueInput<TModelName> | undefined;
 
   /**
-   * Transform validated field data into final Prisma structure for a single item.
+   * 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.
    */
-  buildData: (
-    data: {
-      create: InferFieldsCreateOutput<TFields> &
-        Record<TRelationName, { connect: WhereUniqueInput<TParentModelName> }>;
-      update: InferFieldsUpdateOutput<TFields>;
-    },
+  buildCreateData: (
+    data: InferFieldsCreateOutput<TFields> &
+      Record<TRelationName, { connect: WhereUniqueInput<TParentModelName> }>,
     parentModel: GetPayload<TParentModelName>,
     ctx: TransactionalOperationContext<
       GetPayload<TModelName> | undefined,
       { hasResult: false }
     >,
-  ) =>
-    | Promise<{
-        create: CreateInput<TModelName>;
-        update: UpdateInput<TModelName>;
-      }>
-    | {
-        create: CreateInput<TModelName>;
-        update: UpdateInput<TModelName>;
-      };
+  ) => CreateInput<TModelName> | Promise<CreateInput<TModelName>>;
+
+  /**
+   * Transform validated update field data into final Prisma structure for a single item.
+   */
+  buildUpdateData: (
+    data: InferFieldsUpdateOutput<TFields>,
+    parentModel: GetPayload<TParentModelName>,
+    ctx: TransactionalOperationContext<
+      GetPayload<TModelName> | undefined,
+      { hasResult: false }
+    >,
+  ) => UpdateInput<TModelName> | Promise<UpdateInput<TModelName>>;
 }
 
 /**
@@ -640,9 +618,9 @@ export function nestedOneToManyField<
           if (cachedExisting) return cachedExisting;
           if (!whereUnique) return undefined;
           cachedExisting =
-            (await delegate.findUnique({
+            ((await delegate.findUnique({
               where: { ...whereUnique, ...whereFromOriginalModel },
-            })) ?? undefined;
+            })) as GetPayload<TModelName> | null) ?? undefined;
           return cachedExisting;
         };
       });
@@ -728,9 +706,18 @@ export function nestedOneToManyField<
               ctx.result,
             );
 
-            const builtData = await config.buildData(
-              {
-                create: {
+            const sharedCtx: TransactionalOperationContext<
+              GetPayload<TModelName> | undefined,
+              { hasResult: false }
+            > = {
+              ...ctx,
+              operation: item.whereUnique ? 'update' : 'create',
+              loadExisting: cachedLoadExisting[idx],
+              result: undefined,
+            };
+            const [builtCreate, builtUpdate] = await Promise.all([
+              config.buildCreateData(
+                {
                   ...awaitedData.create,
                   ...({
                     [config.relationName]: { connect: parentWhereUnique },
@@ -739,25 +726,20 @@ export function nestedOneToManyField<
                     { connect: WhereUniqueInput<TParentModelName> }
                   >),
                 },
-                update: awaitedData.update,
-              },
-              ctx.result,
-              {
-                ...ctx,
-                operation: item.whereUnique ? 'update' : 'create',
-                loadExisting: cachedLoadExisting[idx],
-                result: undefined,
-              },
-            );
+                ctx.result,
+                sharedCtx,
+              ),
+              config.buildUpdateData(awaitedData.update, ctx.result, sharedCtx),
+            ]);
 
             results[idx] = item.whereUnique
               ? await prismaDelegate.upsert({
                   where: item.whereUnique,
-                  create: builtData.create,
-                  update: builtData.update,
+                  create: builtCreate,
+                  update: builtUpdate,
                 })
               : await prismaDelegate.create({
-                  data: builtData.create,
+                  data: builtCreate,
                 });
 
             await invokeHooks(item.hooks.afterExecute, {

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

@@ -4,6 +4,7 @@ import type {
   CreateInput,
   GetPayload,
   ModelPropName,
+  ModelQuery,
   UpdateInput,
   WhereInput,
   WhereUniqueInput,
@@ -22,9 +23,10 @@ import type { PrismaTransaction } from '$types';
  * @internal This interface is used internally by the data operations system
  */
 interface GenericPrismaDelegate<TModelName extends ModelPropName> {
-  findUnique: (args: {
+  findUnique: <TQueryArgs extends ModelQuery<TModelName> = object>(args: {
     where: WhereUniqueInput<TModelName>;
-  }) => Promise<GetPayload<TModelName> | null>;
+    include?: NonNullable<ModelQuery<TModelName>['include']>;
+  }) => Promise<GetPayload<TModelName, TQueryArgs> | null>;
   findMany: (args: {
     where: WhereInput<TModelName>;
   }) => Promise<GetPayload<TModelName>[]>;

package/dist/generators/prisma/index.d.ts

@@ -8,6 +8,7 @@ export * from './prisma-data-service/index.js';
 export * from './prisma-data-update/index.js';
 export * from './prisma-enum/index.js';
 export * from './prisma-field/index.js';
+export * from './prisma-model-authorizer/index.js';
 export * from './prisma-model-id/index.js';
 export * from './prisma-model-index/index.js';
 export * from './prisma-model-unique/index.js';

package/dist/generators/prisma/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/prisma/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/prisma/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mBAAmB,CAAC"}

package/dist/generators/prisma/index.js

@@ -8,6 +8,7 @@ export * from './prisma-data-service/index.js';
 export * from './prisma-data-update/index.js';
 export * from './prisma-enum/index.js';
 export * from './prisma-field/index.js';
+export * from './prisma-model-authorizer/index.js';
 export * from './prisma-model-id/index.js';
 export * from './prisma-model-index/index.js';
 export * from './prisma-model-unique/index.js';

package/dist/generators/prisma/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/generators/prisma/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/generators/prisma/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mBAAmB,CAAC"}