@baseplate-dev/fastify-generators 0.5.3 → 0.6.1

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

@@ -0,0 +1,201 @@
+// @ts-nocheck
+
+import type {
+  AnyFieldDefinition,
+  AnyOperationHooks,
+  DataOperationType,
+  InferFieldOutput,
+  InferFieldsCreateOutput,
+  InferFieldsOutput,
+  InferFieldsUpdateOutput,
+  InferInput,
+  InferInputSchema,
+} from '$types';
+import type { ServiceContext } from '%serviceContextImports';
+
+import { z } from 'zod';
+
+/**
+ * Invokes an array of hooks with the provided context.
+ *
+ * All hooks are executed in parallel using `Promise.all`. If no hooks are provided
+ * or the array is empty, this function returns immediately.
+ *
+ * @template TContext - The context type passed to each hook
+ * @param hooks - Optional array of async hook functions to invoke
+ * @param context - The context object passed to each hook
+ * @returns Promise that resolves when all hooks have completed
+ *
+ * @example
+ * ```typescript
+ * await invokeHooks(config.hooks?.beforeExecute, {
+ *   operation: 'create',
+ *   serviceContext: ctx,
+ *   tx: transaction,
+ * });
+ * ```
+ */
+export async function invokeHooks<TContext>(
+  hooks: ((ctx: TContext) => Promise<void>)[] | undefined,
+  context: TContext,
+): Promise<void> {
+  if (!hooks || hooks.length === 0) return;
+  await Promise.all(hooks.map((hook) => hook(context)));
+}
+
+/**
+ * Transforms field definitions into Prisma create/update data structures.
+ *
+ * This function processes each field definition by:
+ * 1. Validating the input value against the field's schema
+ * 2. Transforming the value into Prisma-compatible create/update data
+ * 3. Collecting hooks from each field for execution during the operation lifecycle
+ *
+ * @template TFields - Record of field definitions
+ * @param fields - Field definitions to process
+ * @param input - Input data to validate and transform
+ * @param options - Transformation options
+ * @param options.serviceContext - Service context with user, request info
+ * @param options.operation - Type of operation (create, update, upsert, delete)
+ * @param options.allowOptionalFields - Whether to allow undefined field values
+ * @param options.loadExisting - Function to load existing model data
+ * @returns Object containing transformed data and collected hooks
+ *
+ * @example
+ * ```typescript
+ * const { data, hooks } = await transformFields(
+ *   { name: scalarField(z.string()), email: scalarField(z.email()) },
+ *   { name: 'John', email: 'john@example.com' },
+ *   {
+ *     serviceContext: ctx,
+ *     operation: 'create',
+ *     allowOptionalFields: false,
+ *     loadExisting: () => Promise.resolve(undefined),
+ *   },
+ * );
+ * ```
+ */
+export async function transformFields<
+  TFields extends Record<string, AnyFieldDefinition>,
+>(
+  fields: TFields,
+  input: InferInput<TFields>,
+  {
+    serviceContext,
+    operation,
+    allowOptionalFields,
+    loadExisting,
+  }: {
+    serviceContext: ServiceContext;
+    operation: DataOperationType;
+    allowOptionalFields: boolean;
+    loadExisting: () => Promise<object | undefined>;
+  },
+): Promise<{
+  data: InferFieldsOutput<TFields>;
+  hooks: AnyOperationHooks;
+}> {
+  const hooks: Required<AnyOperationHooks> = {
+    beforeExecute: [],
+    afterExecute: [],
+    afterCommit: [],
+  };
+
+  const data = {} as {
+    [K in keyof TFields]: InferFieldOutput<TFields[K]>;
+  };
+
+  for (const [key, field] of Object.entries(fields)) {
+    const fieldKey = key as keyof typeof input;
+    const value = input[fieldKey];
+
+    if (allowOptionalFields && value === undefined) continue;
+
+    const result = await field.processInput(value, {
+      operation,
+      serviceContext,
+      fieldName: fieldKey as string,
+      loadExisting,
+    });
+
+    if (result.data !== undefined) {
+      data[fieldKey as keyof TFields] = result.data as InferFieldOutput<
+        TFields[keyof TFields]
+      >;
+    }
+
+    if (result.hooks) {
+      hooks.beforeExecute.push(...(result.hooks.beforeExecute ?? []));
+      hooks.afterExecute.push(...(result.hooks.afterExecute ?? []));
+      hooks.afterCommit.push(...(result.hooks.afterCommit ?? []));
+    }
+  }
+
+  const create = {} as InferFieldsCreateOutput<TFields>;
+  const update = {} as InferFieldsUpdateOutput<TFields>;
+  for (const [key, value] of Object.entries<
+    InferFieldOutput<TFields[keyof TFields]>
+  >(data)) {
+    if (value.create !== undefined) {
+      create[key as keyof TFields] =
+        value.create as InferFieldsCreateOutput<TFields>[keyof TFields];
+    }
+    if (value.update !== undefined) {
+      update[key as keyof TFields] =
+        value.update as InferFieldsUpdateOutput<TFields>[keyof TFields];
+    }
+  }
+
+  return { data: { create, update }, hooks };
+}
+
+/**
+ * =========================================
+ * Schema Generation Utilities
+ * =========================================
+ */
+
+/**
+ * Generates a Zod schema for create operations from field definitions.
+ *
+ * Extracts the Zod schema from each field definition and combines them
+ * into a single object schema. This schema can be used for validation
+ * in GraphQL resolvers, REST endpoints, tRPC procedures, or OpenAPI documentation.
+ *
+ * @template TFields - Record of field definitions
+ * @param fields - Field definitions to extract schemas from
+ * @returns Zod object schema preserving each field's optionality
+ */
+export function generateCreateSchema<
+  TFields extends Record<string, AnyFieldDefinition>,
+>(fields: TFields): InferInputSchema<TFields> {
+  const shape = Object.fromEntries(
+    Object.entries(fields).map(([key, field]) => [key, field.schema]),
+  ) as {
+    [K in keyof TFields]: TFields[K]['schema'];
+  };
+
+  return z.object(shape) as InferInputSchema<TFields>;
+}
+
+type PartialSchema<T extends z.ZodObject<z.ZodRawShape>> = z.ZodObject<{
+  [K in keyof T['shape']]: z.ZodOptional<T['shape'][K]>;
+}>;
+
+/**
+ * Generates a Zod schema for update operations from field definitions.
+ *
+ * Wraps {@link generateCreateSchema} with `.partial()` so every field becomes
+ * optional, allowing callers to supply only the fields they want to change.
+ *
+ * @template TFields - Record of field definitions
+ * @param fields - Field definitions to extract schemas from
+ * @returns Partial Zod object schema where all fields are optional
+ */
+export function generateUpdateSchema<
+  TFields extends Record<string, AnyFieldDefinition>,
+>(fields: TFields): PartialSchema<InferInputSchema<TFields>> {
+  return generateCreateSchema(fields).partial() as PartialSchema<
+    InferInputSchema<TFields>
+  >;
+}

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

@@ -16,10 +16,12 @@ export type ModelPropName = Prisma.TypeMap['meta']['modelProps'];
  * Infers the return type of a Prisma query for a given model and query arguments.
  *
  * This type extracts the shape of data returned from a Prisma query, respecting
- * any `select` or `include` arguments provided.
+ * any `include` arguments provided. Only the `include` key from `TIncludeArgs` is
+ * forwarded to Prisma's Result type; `select` is stripped to avoid producing
+ * an unresolvable union type.
  *
  * @template TModelName - The Prisma model name
- * @template TQueryArgs - Optional query arguments (select/include)
+ * @template TIncludeArgs - Optional query arguments (include only)
  *
  * @example
  * ```typescript
@@ -28,41 +30,43 @@ export type ModelPropName = Prisma.TypeMap['meta']['modelProps'];
  *
  * // User with posts included
  * type UserWithPosts = GetPayload<'user', { include: { posts: true } }>;
- *
- * // User with only specific fields
- * type UserNameEmail = GetPayload<'user', { select: { name: true, email: true } }>;
  * ```
  */
 export type GetPayload<
   TModelName extends ModelPropName,
-  TQueryArgs = undefined,
-> = Result<(typeof prisma)[TModelName], TQueryArgs, 'findUniqueOrThrow'>;
+  TIncludeArgs = undefined,
+> = Result<
+  (typeof prisma)[TModelName],
+  TIncludeArgs extends undefined
+    ? undefined
+    : { include: TIncludeArgs extends { include?: infer I } ? I : undefined },
+  'findUniqueOrThrow'
+>;
 
 /**
- * Type for Prisma query arguments (select/include) for a given model.
+ * Type for Prisma include arguments for a given model.
  *
  * Used to shape the returned data from database operations by specifying
- * which fields to select or which relations to include.
+ * which relations to include. Only `include` is supported; `select` is
+ * accepted as `undefined` for compatibility with `queryFromInfo()` but
+ * will be stripped by `GetPayload`.
  *
  * @template TModelName - The Prisma model name
  *
  * @example
  * ```typescript
- * const query: ModelQuery<'user'> = {
- *   select: { id: true, name: true, email: true },
- * };
- *
- * const queryWithInclude: ModelQuery<'user'> = {
+ * const query: ModelInclude<'user'> = {
  *   include: { posts: true, profile: true },
  * };
  * ```
  */
-export type ModelQuery<TModelName extends ModelPropName> = Pick<
-  { select?: unknown; include?: unknown } & Args<
-    (typeof prisma)[TModelName],
-    'findUnique'
-  >,
-  'select' | 'include'
+export type ModelInclude<TModelName extends ModelPropName> = {
+  select?: undefined;
+} & Pick<
+  Args<(typeof prisma)[TModelName], 'findUnique'> extends { include?: infer I }
+    ? { include?: I }
+    : { include?: undefined },
+  'include'
 >;
 
 /**

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

@@ -3,13 +3,14 @@
 import type {
   CreateInput,
   GetPayload,
+  ModelInclude,
   ModelPropName,
-  ModelQuery,
   UpdateInput,
   WhereInput,
   WhereUniqueInput,
 } from '$prismaTypes';
-import type { PrismaTransaction } from '$types';
+import type { Prisma } from '%prismaGeneratedImports';
+import type { prisma } from '%prismaImports';
 
 /**
  * Generic interface for Prisma model delegates.
@@ -23,10 +24,17 @@ import type { PrismaTransaction } from '$types';
  * @internal This interface is used internally by the data operations system
  */
 interface GenericPrismaDelegate<TModelName extends ModelPropName> {
-  findUnique: <TQueryArgs extends ModelQuery<TModelName> = object>(args: {
+  findUnique: <
+    TInclude extends
+      | NonNullable<ModelInclude<TModelName>['include']>
+      | undefined = undefined,
+  >(args: {
     where: WhereUniqueInput<TModelName>;
-    include?: NonNullable<ModelQuery<TModelName>['include']>;
-  }) => Promise<GetPayload<TModelName, TQueryArgs> | null>;
+    include?: TInclude;
+  }) => Promise<GetPayload<
+    TModelName,
+    TInclude extends undefined ? undefined : { include: TInclude }
+  > | null>;
   findMany: (args: {
     where: WhereInput<TModelName>;
   }) => Promise<GetPayload<TModelName>[]>;
@@ -75,7 +83,7 @@ interface GenericPrismaDelegate<TModelName extends ModelPropName> {
  * @internal This function is used internally by nested field handlers
  */
 export function makeGenericPrismaDelegate<TModelName extends ModelPropName>(
-  tx: PrismaTransaction,
+  tx: Prisma.TransactionClient | typeof prisma,
   modelName: TModelName,
 ): GenericPrismaDelegate<TModelName> {
   return tx[modelName] as unknown as GenericPrismaDelegate<TModelName>;

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

@@ -108,7 +108,7 @@ function connectCreate<
  * owner: relationHelpers.connectUpdate({ userId: null, tenantId: 'tenant-1' })
  *
  * @example
- * // Composite key - no change (if any field is undefined)
+ * // Composite key - no change (if any field is undefined, the entire relation is unchanged)
  * owner: relationHelpers.connectUpdate({ userId: undefined, tenantId: 'tenant-1' })
  */
 function connectUpdate<
@@ -151,33 +151,28 @@ function connectUpdate<
  * support for both single-field and composite key relations.
  *
  * @example
- * // In a create operation with single field relations
- * buildData: ({ todoListId, assigneeId, ...rest }) => ({
- *   todoList: relationHelpers.connectCreate({ id: todoListId }),
- *   assignee: relationHelpers.connectCreate({ id: assigneeId }), // undefined if assigneeId is null
- *   ...rest,
- * })
+ * // In a create execute function with single field relations
+ * execute: async ({ tx, data: { todoListId, assigneeId, ...rest }, query }) =>
+ *   tx.todoItem.create({
+ *     data: {
+ *       todoList: relationHelpers.connectCreate({ id: todoListId }),
+ *       assignee: relationHelpers.connectCreate({ id: assigneeId }),
+ *       ...rest,
+ *     },
+ *     ...query,
+ *   })
  *
  * @example
- * // In a create operation with composite key relation
- * buildData: ({ userId, tenantId, ...rest }) => ({
- *   owner: relationHelpers.connectCreate({ userId, tenantId }), // undefined if any field is null
- *   ...rest,
- * })
- *
- * @example
- * // In an update operation with single field
- * buildData: ({ assigneeId, ...rest }) => ({
- *   assignee: relationHelpers.connectUpdate({ id: assigneeId }),
- *   ...rest,
- * })
- *
- * @example
- * // In an update operation with composite key
- * buildData: ({ userId, tenantId, ...rest }) => ({
- *   owner: relationHelpers.connectUpdate({ userId, tenantId }),
- *   ...rest,
- * })
+ * // In an update execute function with single field
+ * execute: async ({ tx, data: { assigneeId, ...rest }, query }) =>
+ *   tx.todoItem.update({
+ *     where,
+ *     data: {
+ *       assignee: relationHelpers.connectUpdate({ id: assigneeId }),
+ *       ...rest,
+ *     },
+ *     ...query,
+ *   })
  */
 export const relationHelpers = {
   /**