@baseplate-dev/fastify-generators 0.5.3 → 0.6.0

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/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 = {
   /**

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

@@ -1,5 +1,15 @@
 // @ts-nocheck
 
+import type {
+  GetPayload,
+  ModelPropName,
+  ModelQuery,
+  WhereUniqueInput,
+} from '$prismaTypes';
+import type {
+  GlobalRoleCheck,
+  InstanceRoleCheck,
+} from '%authorizerUtilsImports';
 import type { PrismaClient } from '%prismaGeneratedImports';
 import type { ServiceContext } from '%serviceContextImports';
 import type { ITXClientDenyList } from '@prisma/client/runtime/client';
@@ -166,22 +176,14 @@ export interface FieldTransformData<TCreateOutput, TUpdateOutput> {
 /**
  * Result of field processing, including transformed data and optional hooks.
  *
- * The data can be either synchronous or asynchronous (resolved inside transaction).
  * Hooks allow fields to perform side effects during the operation lifecycle.
  *
  * @template TCreateOutput - Data type for create operations
  * @template TUpdateOutput - Data type for update operations
  */
 export interface FieldTransformResult<TCreateOutput, TUpdateOutput> {
-  /**
-   * Transformed field data or an async function that resolves to field data.
-   * Async functions are resolved inside the transaction, allowing access to tx client.
-   */
-  data?:
-    | FieldTransformData<TCreateOutput, TUpdateOutput>
-    | ((
-        tx: PrismaTransaction,
-      ) => Promise<FieldTransformData<TCreateOutput, TUpdateOutput>>);
+  /** Transformed field data for create and update operations */
+  data?: FieldTransformData<TCreateOutput, TUpdateOutput>;
 
   /** Optional hooks to execute during operation lifecycle */
   hooks?: AnyOperationHooks;
@@ -228,10 +230,8 @@ export interface FieldDefinition<
   schema: TInputSchema;
 
   /**
-   * Processes and transforms an input value.
-   *
-   * Note: Validation happens at the operation level (defineCreateOperation/defineUpdateOperation),
-   * not at the field level. This function receives already-validated input.
+   * Processes and transforms an already-validated input value into
+   * Prisma-compatible create/update data.
    *
    * @param value - The validated input value to process
    * @param ctx - Context about the operation
@@ -370,3 +370,361 @@ export interface InferFieldsOutput<
   /** Field outputs for update operations */
   update: InferFieldsUpdateOutput<TFields>;
 }
+
+/**
+ * =========================================
+ * Operation Plans
+ * =========================================
+ */
+
+type HookPhase = keyof Required<AnyOperationHooks>;
+type HookFn<TPhase extends HookPhase> =
+  Required<AnyOperationHooks>[TPhase][number];
+
+/**
+ * Immutable plan for a create operation, returned by `composeCreate`.
+ *
+ * Contains the resolved field data, collected hooks, and service context.
+ * Use `mapData` and `addHook` to derive new plans — the original is never mutated.
+ */
+export class CreatePlan<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+> {
+  /** The Prisma model name */
+  readonly model: TModelName;
+
+  /** Resolved field data for the create operation */
+  readonly data: InferFieldsCreateOutput<TFields>;
+
+  /** Collected hooks from field processing and any `addHook` calls */
+  readonly hooks: Readonly<Required<AnyOperationHooks>>;
+
+  /** Service context for the operation */
+  readonly serviceContext: ServiceContext;
+
+  constructor(args: {
+    model: TModelName;
+    data: InferFieldsCreateOutput<TFields>;
+    hooks: Required<AnyOperationHooks>;
+    serviceContext: ServiceContext;
+  }) {
+    this.model = args.model;
+    this.data = args.data;
+    this.hooks = args.hooks;
+    this.serviceContext = args.serviceContext;
+  }
+
+  /** Return a new plan with transformed data. */
+  mapData(
+    fn: (
+      data: InferFieldsCreateOutput<TFields>,
+    ) => InferFieldsCreateOutput<TFields>,
+  ): CreatePlan<TModelName, TFields> {
+    return new CreatePlan({
+      model: this.model,
+      data: fn(this.data),
+      hooks: this.hooks,
+      serviceContext: this.serviceContext,
+    });
+  }
+
+  /** Return a new plan with an additional hook appended to the given phase. */
+  addHook<TPhase extends HookPhase>(
+    phase: TPhase,
+    hook: HookFn<TPhase>,
+  ): CreatePlan<TModelName, TFields> {
+    return new CreatePlan({
+      model: this.model,
+      data: this.data,
+      hooks: {
+        ...this.hooks,
+        [phase]: [...this.hooks[phase], hook],
+      },
+      serviceContext: this.serviceContext,
+    });
+  }
+}
+
+/**
+ * Immutable plan for an update operation, returned by `composeUpdate`.
+ *
+ * Contains the resolved field data, collected hooks, existing item access,
+ * and service context. Use `mapData` and `addHook` to derive new plans —
+ * the original is never mutated.
+ */
+export class UpdatePlan<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+> {
+  /** The Prisma model name */
+  readonly model: TModelName;
+
+  /** Resolved field data for the update operation */
+  readonly data: InferFieldsUpdateOutput<TFields>;
+
+  /** Collected hooks from field processing and any `addHook` calls */
+  readonly hooks: Readonly<Required<AnyOperationHooks>>;
+
+  /** Service context for the operation */
+  readonly serviceContext: ServiceContext;
+
+  /**
+   * Lazy loader for the existing item. Caches the result.
+   * Call this if you need to inspect the existing item for diffing.
+   */
+  readonly loadExisting: () => Promise<GetPayload<TModelName>>;
+
+  constructor(args: {
+    model: TModelName;
+    data: InferFieldsUpdateOutput<TFields>;
+    hooks: Required<AnyOperationHooks>;
+    serviceContext: ServiceContext;
+    loadExisting: () => Promise<GetPayload<TModelName>>;
+  }) {
+    this.model = args.model;
+    this.data = args.data;
+    this.hooks = args.hooks;
+    this.serviceContext = args.serviceContext;
+    this.loadExisting = args.loadExisting;
+  }
+
+  /** Return a new plan with transformed data. */
+  mapData(
+    fn: (
+      data: InferFieldsUpdateOutput<TFields>,
+    ) => InferFieldsUpdateOutput<TFields>,
+  ): UpdatePlan<TModelName, TFields> {
+    return new UpdatePlan({
+      model: this.model,
+      data: fn(this.data),
+      hooks: this.hooks,
+      serviceContext: this.serviceContext,
+      loadExisting: this.loadExisting,
+    });
+  }
+
+  /** Return a new plan with an additional hook appended to the given phase. */
+  addHook<TPhase extends HookPhase>(
+    phase: TPhase,
+    hook: HookFn<TPhase>,
+  ): UpdatePlan<TModelName, TFields> {
+    return new UpdatePlan({
+      model: this.model,
+      data: this.data,
+      hooks: {
+        ...this.hooks,
+        [phase]: [...this.hooks[phase], hook],
+      },
+      serviceContext: this.serviceContext,
+      loadExisting: this.loadExisting,
+    });
+  }
+}
+
+/**
+ * =========================================
+ * Compose Configs
+ * =========================================
+ */
+
+/**
+ * Configuration for `composeCreate`.
+ */
+export interface ComposeCreateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+> {
+  model: TModelName;
+  fields: TFields;
+  input: InferInput<TFields>;
+  context: ServiceContext;
+
+  /**
+   * Optional authorization checks. Only global roles are allowed for create
+   * since there is no existing instance to check against.
+   * Runs before field processing — fails fast on unauthorized access.
+   */
+  authorize?: GlobalRoleCheck[];
+}
+
+/**
+ * Configuration for `composeUpdate`.
+ *
+ * The `loadExisting` function is a cached lazy loader for the existing item.
+ * It is called by field processing (e.g., nested relations) when they need
+ * to read the current state. The caller defines this function to control
+ * how the item is fetched (e.g., with extra includes).
+ */
+export interface ComposeUpdateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+> {
+  model: TModelName;
+  fields: TFields;
+  input: Partial<InferInput<TFields>>;
+  context: ServiceContext;
+  loadExisting: () => Promise<GetPayload<TModelName>>;
+
+  /**
+   * Optional authorization checks. Supports both global roles (strings)
+   * and instance-level checks (functions that receive the existing item).
+   * Runs before field processing — fails fast on unauthorized access.
+   */
+  authorize?: (GlobalRoleCheck | InstanceRoleCheck<GetPayload<TModelName>>)[];
+}
+
+/**
+ * =========================================
+ * Data Service Input Types
+ * =========================================
+ */
+
+/**
+ * Input type for data service create functions.
+ */
+export interface DataCreateInput<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TQueryArgs extends ModelQuery<TModelName> = ModelQuery<TModelName>,
+> {
+  data: InferInput<TFields>;
+  query?: TQueryArgs;
+  context: ServiceContext;
+}
+
+/**
+ * Input type for data service update functions.
+ */
+export interface DataUpdateInput<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TQueryArgs extends ModelQuery<TModelName> = ModelQuery<TModelName>,
+> {
+  where: WhereUniqueInput<TModelName>;
+  data: Partial<InferInput<TFields>>;
+  query?: TQueryArgs;
+  context: ServiceContext;
+}
+
+/**
+ * Input type for data service delete functions.
+ */
+export interface DataDeleteInput<
+  TModelName extends ModelPropName,
+  TQueryArgs extends ModelQuery<TModelName> = ModelQuery<TModelName>,
+> {
+  where: WhereUniqueInput<TModelName>;
+  query?: TQueryArgs;
+  context: ServiceContext;
+}
+
+/**
+ * =========================================
+ * Commit Configs
+ * =========================================
+ */
+
+/**
+ * Configuration for `commitCreate`.
+ */
+export interface CommitCreateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TQueryArgs extends ModelQuery<TModelName>,
+> {
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TQueryArgs;
+
+  /**
+   * Optional override for the default refetch behavior.
+   * By default, records are refetched using `findUnique({ where: { id } })`
+   * via a generic Prisma delegate. Provide this if you need custom refetch logic.
+   */
+  refetchWithQuery?: (
+    result: GetPayload<TModelName>,
+    query: TQueryArgs,
+  ) => Promise<GetPayload<TModelName>>;
+
+  /** Execute the Prisma create operation inside the transaction */
+  execute: (args: {
+    tx: PrismaTransaction;
+    data: InferFieldsCreateOutput<TFields>;
+    query: { include: NonNullable<TQueryArgs['include']> };
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName>>;
+}
+
+/**
+ * Configuration for `commitUpdate`.
+ */
+export interface CommitUpdateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TQueryArgs extends ModelQuery<TModelName>,
+> {
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TQueryArgs;
+
+  /**
+   * Optional override for the default refetch behavior.
+   * By default, records are refetched using `findUnique({ where: { id } })`
+   * via a generic Prisma delegate. Provide this if you need custom refetch logic.
+   */
+  refetchWithQuery?: (
+    result: GetPayload<TModelName>,
+    query: TQueryArgs,
+  ) => Promise<GetPayload<TModelName>>;
+
+  /** Execute the Prisma update operation inside the transaction */
+  execute: (args: {
+    tx: PrismaTransaction;
+    data: InferFieldsUpdateOutput<TFields>;
+    query: { include: NonNullable<TQueryArgs['include']> };
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName>>;
+}
+
+/**
+ * Configuration for `commitDelete`.
+ *
+ * Delete has no compose step since there are no fields to process.
+ * Authorization, hooks, and execution are all handled directly.
+ */
+export interface CommitDeleteConfig<
+  TModelName extends ModelPropName,
+  TQueryArgs extends ModelQuery<TModelName>,
+> {
+  /** The Prisma model name */
+  model: TModelName;
+
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TQueryArgs;
+
+  /** Service context for the operation */
+  context: ServiceContext;
+
+  /**
+   * Optional authorization checks. Supports both global roles (strings)
+   * and instance-level checks (functions that receive the existing item).
+   * Runs before hooks and delete execution.
+   */
+  authorize?: (GlobalRoleCheck | InstanceRoleCheck<GetPayload<TModelName>>)[];
+
+  /** Optional hooks to run during the delete lifecycle */
+  hooks?: Partial<AnyOperationHooks>;
+
+  /**
+   * Lazy loader for the existing item. Required when using instance-level
+   * authorization or hooks that need to inspect the record before deletion.
+   * The result is cached so the item is fetched at most once.
+   */
+  loadExisting?: () => Promise<GetPayload<TModelName>>;
+
+  /** Execute the Prisma delete operation inside the transaction */
+  execute: (args: {
+    tx: PrismaTransaction;
+    query: { include: NonNullable<TQueryArgs['include']> };
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName>>;
+}

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

@@ -11,8 +11,10 @@ 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-query-filter/index.js';
 export * from './prisma-model-unique/index.js';
 export * from './prisma-model/index.js';
+export * from './prisma-query-filter-utils/index.js';
 export * from './prisma-relation-field/index.js';
 export * from './prisma/index.js';
 //# sourceMappingURL=index.d.ts.map

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,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"}
+{"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,sCAAsC,CAAC;AACrD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mBAAmB,CAAC"}