@baseplate-dev/fastify-generators 0.3.8 → 0.4.0

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

@@ -0,0 +1,164 @@
+// @ts-nocheck
+
+import type { Prisma } from '%prismaGeneratedImports';
+import type { prisma } from '%prismaImports';
+import type { Args, Result } from '@prisma/client/runtime/client';
+
+/**
+ * Union type of all Prisma model names (e.g., 'user', 'post', 'comment').
+ *
+ * Used as a constraint for generic type parameters to ensure only valid
+ * Prisma model names are used.
+ */
+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.
+ *
+ * @template TModelName - The Prisma model name
+ * @template TQueryArgs - Optional query arguments (select/include)
+ *
+ * @example
+ * ```typescript
+ * // Basic user type
+ * type User = GetPayload<'user'>;
+ *
+ * // 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'>;
+
+/**
+ * Type for Prisma query arguments (select/include) for a given model.
+ *
+ * Used to shape the returned data from database operations by specifying
+ * which fields to select or which relations to include.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @example
+ * ```typescript
+ * const query: ModelQuery<'user'> = {
+ *   select: { id: true, name: true, email: true },
+ * };
+ *
+ * const queryWithInclude: ModelQuery<'user'> = {
+ *   include: { posts: true, profile: true },
+ * };
+ * ```
+ */
+export type ModelQuery<TModelName extends ModelPropName> = Pick<
+  { select?: unknown; include?: unknown } & Args<
+    (typeof prisma)[TModelName],
+    'findUnique'
+  >,
+  'select' | 'include'
+>;
+
+/**
+ * Type for Prisma where clauses for filtering records.
+ *
+ * Used in `findMany`, `updateMany`, `deleteMany` operations to specify
+ * which records to operate on.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @example
+ * ```typescript
+ * const where: WhereInput<'user'> = {
+ *   email: { contains: '@example.com' },
+ *   AND: [{ isActive: true }, { createdAt: { gt: new Date('2024-01-01') } }],
+ * };
+ * ```
+ */
+export type WhereInput<TModelName extends ModelPropName> = Args<
+  (typeof prisma)[TModelName],
+  'findMany'
+>['where'];
+
+/**
+ * Type for Prisma unique where clauses for finding a single record.
+ *
+ * Used in `findUnique`, `update`, `delete`, and `upsert` operations
+ * to specify which record to operate on using unique fields.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @example
+ * ```typescript
+ * // By ID
+ * const where1: WhereUniqueInput<'user'> = { id: 'user-123' };
+ *
+ * // By unique email
+ * const where2: WhereUniqueInput<'user'> = { email: 'user@example.com' };
+ *
+ * // By compound unique constraint
+ * const where3: WhereUniqueInput<'membership'> = {
+ *   userId_teamId: { userId: 'user-1', teamId: 'team-1' },
+ * };
+ * ```
+ */
+export type WhereUniqueInput<TModelName extends ModelPropName> = Args<
+  (typeof prisma)[TModelName],
+  'findUnique'
+>['where'];
+
+/**
+ * Type for Prisma create input data for a given model.
+ *
+ * Represents the shape of data accepted by `create` operations.
+ * Includes all required fields and optional fields, with support for
+ * nested creates via relation fields.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @example
+ * ```typescript
+ * const createData: CreateInput<'user'> = {
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   posts: {
+ *     create: [{ title: 'First post', content: '...' }],
+ *   },
+ * };
+ * ```
+ */
+export type CreateInput<TModelName extends ModelPropName> = Args<
+  (typeof prisma)[TModelName],
+  'create'
+>['data'];
+
+/**
+ * Type for Prisma update input data for a given model.
+ *
+ * Represents the shape of data accepted by `update` operations.
+ * All fields are optional (partial updates), with support for
+ * nested updates, creates, and deletes via relation fields.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @example
+ * ```typescript
+ * const updateData: UpdateInput<'user'> = {
+ *   name: 'Jane Doe', // Only updating name
+ *   posts: {
+ *     update: [{ where: { id: 'post-1' }, data: { title: 'Updated title' } }],
+ *     create: [{ title: 'New post', content: '...' }],
+ *   },
+ * };
+ * ```
+ */
+export type UpdateInput<TModelName extends ModelPropName> = Args<
+  (typeof prisma)[TModelName],
+  'update'
+>['data'];

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

@@ -0,0 +1,80 @@
+// @ts-nocheck
+
+import type {
+  CreateInput,
+  GetPayload,
+  ModelPropName,
+  UpdateInput,
+  WhereInput,
+  WhereUniqueInput,
+} from '$prismaTypes';
+import type { PrismaTransaction } from '$types';
+
+/**
+ * Generic interface for Prisma model delegates.
+ *
+ * Provides a type-safe way to interact with any Prisma model through
+ * a common set of operations. Used internally by the data operations
+ * system to perform database operations on models determined at runtime.
+ *
+ * @template TModelName - The Prisma model name
+ *
+ * @internal This interface is used internally by the data operations system
+ */
+interface GenericPrismaDelegate<TModelName extends ModelPropName> {
+  findUnique: (args: {
+    where: WhereUniqueInput<TModelName>;
+  }) => Promise<GetPayload<TModelName> | null>;
+  findMany: (args: {
+    where: WhereInput<TModelName>;
+  }) => Promise<GetPayload<TModelName>[]>;
+  create: (args: {
+    data: CreateInput<TModelName>;
+  }) => Promise<GetPayload<TModelName>>;
+  update: (args: {
+    where: WhereUniqueInput<TModelName>;
+    data: UpdateInput<TModelName>;
+  }) => Promise<GetPayload<TModelName>>;
+  upsert: (args: {
+    where: WhereUniqueInput<TModelName>;
+    create: CreateInput<TModelName>;
+    update: UpdateInput<TModelName>;
+  }) => Promise<GetPayload<TModelName>>;
+  delete: (args: {
+    where: WhereUniqueInput<TModelName>;
+  }) => Promise<GetPayload<TModelName>>;
+  deleteMany: (args: {
+    where: WhereInput<TModelName>;
+  }) => Promise<{ count: number }>;
+}
+
+/**
+ * Creates a type-safe generic delegate for a Prisma model.
+ *
+ * This function allows accessing Prisma model operations (findUnique, create, update, etc.)
+ * in a type-safe way when the model name is only known at runtime. It's used internally
+ * by nested field handlers and other generic operations.
+ *
+ * @template TModelName - The Prisma model name
+ * @param tx - Prisma transaction client
+ * @param modelName - The name of the model to create a delegate for (e.g., 'user', 'post')
+ * @returns A generic delegate providing type-safe access to model operations
+ *
+ * @example
+ * ```typescript
+ * const delegate = makeGenericPrismaDelegate(tx, 'user');
+ *
+ * // Type-safe operations
+ * const user = await delegate.findUnique({ where: { id: userId } });
+ * const users = await delegate.findMany({ where: { isActive: true } });
+ * const newUser = await delegate.create({ data: { name: 'John', email: 'john@example.com' } });
+ * ```
+ *
+ * @internal This function is used internally by nested field handlers
+ */
+export function makeGenericPrismaDelegate<TModelName extends ModelPropName>(
+  tx: PrismaTransaction,
+  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

@@ -0,0 +1,196 @@
+// @ts-nocheck
+
+/**
+ * Type helper to check if a record type has any undefined values.
+ *
+ * @template T - Record type to check
+ */
+type HasUndefinedValues<T extends Record<string, unknown>> =
+  undefined extends T[keyof T] ? true : false;
+
+/**
+ * Type helper to check if a record type has any null values.
+ *
+ * @template T - Record type to check
+ */
+type HasNullValues<T extends Record<string, unknown>> = null extends T[keyof T]
+  ? true
+  : false;
+
+/**
+ * Type helper to check if a record type has any undefined or null values.
+ * Used for conditional return types in relation helpers.
+ *
+ * @template T - Record type to check
+ */
+type HasUndefinedOrNullValues<T extends Record<string, unknown>> =
+  HasUndefinedValues<T> extends true
+    ? true
+    : HasNullValues<T> extends true
+      ? true
+      : false;
+
+/**
+ * Creates a Prisma connect object for create operations
+ *
+ * Returns undefined if any value in the data object is null or undefined,
+ * allowing optional relations in create operations.
+ *
+ * @template TUniqueWhere - Object containing the unique identifier(s) for the relation
+ * @param data - Object with one or more key-value pairs representing the unique identifier(s)
+ * @returns Prisma connect object or undefined if any value is null/undefined
+ *
+ * @example
+ * // Single field - required relation
+ * todoList: relationHelpers.connectCreate({ id: todoListId })
+ *
+ * @example
+ * // Single field - optional relation (returns undefined if assigneeId is null/undefined)
+ * assignee: relationHelpers.connectCreate({ id: assigneeId })
+ *
+ * @example
+ * // Composite key - required relation
+ * owner: relationHelpers.connectCreate({ userId, tenantId })
+ *
+ * @example
+ * // Composite key - optional relation (returns undefined if any field is null/undefined)
+ * assignee: relationHelpers.connectCreate({ userId, organizationId })
+ */
+function connectCreate<
+  TUniqueWhere extends Record<string, string | undefined | null>,
+>(
+  data: TUniqueWhere,
+):
+  | (HasUndefinedOrNullValues<TUniqueWhere> extends true ? undefined : never)
+  | { connect: { [K in keyof TUniqueWhere]: string } } {
+  const values = Object.values(data);
+  // Return undefined if any value is null or undefined (for optional relations)
+  if (values.some((value) => value === undefined || value === null)) {
+    return undefined as HasUndefinedOrNullValues<TUniqueWhere> extends true
+      ? undefined
+      : never;
+  }
+  return {
+    connect: data as { [K in keyof TUniqueWhere]: string },
+  };
+}
+
+/**
+ * Creates a Prisma connect/disconnect object for update operations
+ *
+ * Handles three cases:
+ * - All values present: returns connect object to update the relation
+ * - Any value is null: returns { disconnect: true } to remove the relation
+ * - Any value is undefined: returns undefined to leave the relation unchanged
+ *
+ * @template TUniqueWhere - Object containing the unique identifier(s) for the relation
+ * @param data - Object with one or more key-value pairs representing the unique identifier(s)
+ * @returns Prisma connect/disconnect object, or undefined if no change
+ *
+ * @example
+ * // Single field - update to a new assignee
+ * assignee: relationHelpers.connectUpdate({ id: 'user-2' })
+ *
+ * @example
+ * // Single field - disconnect the assignee (set to null)
+ * assignee: relationHelpers.connectUpdate({ id: null })
+ *
+ * @example
+ * // Single field - leave the assignee unchanged
+ * assignee: relationHelpers.connectUpdate({ id: undefined })
+ *
+ * @example
+ * // Composite key - update to a new relation
+ * owner: relationHelpers.connectUpdate({ userId: 'user-2', tenantId: 'tenant-1' })
+ *
+ * @example
+ * // Composite key - disconnect (if any field is null)
+ * owner: relationHelpers.connectUpdate({ userId: null, tenantId: 'tenant-1' })
+ *
+ * @example
+ * // Composite key - no change (if any field is undefined)
+ * owner: relationHelpers.connectUpdate({ userId: undefined, tenantId: 'tenant-1' })
+ */
+function connectUpdate<
+  TUniqueWhere extends Record<string, string | undefined | null>,
+>(
+  data: TUniqueWhere,
+):
+  | (HasUndefinedValues<TUniqueWhere> extends true ? undefined : never)
+  | (HasNullValues<TUniqueWhere> extends true ? { disconnect: true } : never)
+  | { connect: { [K in keyof TUniqueWhere]: string } } {
+  const values = Object.values(data);
+  const hasUndefined = values.includes(undefined);
+  const hasNull = values.includes(null);
+
+  // If any value is undefined, leave relation unchanged
+  if (hasUndefined) {
+    return undefined as HasUndefinedValues<TUniqueWhere> extends true
+      ? undefined
+      : never;
+  }
+
+  // If any value is null, disconnect the relation
+  if (hasNull) {
+    return {
+      disconnect: true,
+    } as HasNullValues<TUniqueWhere> extends true
+      ? { disconnect: true }
+      : never;
+  }
+
+  // All values are present, connect to the new relation
+  return { connect: data as { [K in keyof TUniqueWhere]: string } };
+}
+
+/**
+ * Relation helpers for transforming scalar IDs into Prisma relation objects
+ *
+ * These helpers provide type-safe ways to connect and disconnect relations
+ * in Prisma operations, with proper handling of optional relations and
+ * 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,
+ * })
+ *
+ * @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,
+ * })
+ */
+export const relationHelpers = {
+  /**
+   * Creates a connect object for create operations
+   * Returns undefined if the ID is null or undefined
+   */
+  connectCreate,
+
+  /**
+   * Creates a connect/disconnect object for update operations
+   * - null: disconnects the relation
+   * - undefined: no change to the relation
+   * - value: connects to the new relation
+   */
+  connectUpdate,
+};