@baseplate-dev/fastify-generators 0.5.3 → 0.6.1

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

@@ -1,18 +1,19 @@
 // @ts-nocheck
 
-import type { PrismaClient } from '%prismaGeneratedImports';
+import type {
+  GetPayload,
+  ModelInclude,
+  ModelPropName,
+  WhereUniqueInput,
+} from '$prismaTypes';
+import type {
+  GlobalRoleCheck,
+  InstanceRoleCheck,
+} from '%authorizerUtilsImports';
+import type { Prisma } from '%prismaGeneratedImports';
 import type { ServiceContext } from '%serviceContextImports';
-import type { ITXClientDenyList } from '@prisma/client/runtime/client';
 import type { z } from 'zod';
 
-/**
- * Prisma transaction client type for data operations.
- *
- * This is the Prisma client type available within transaction callbacks,
- * with operations that cannot be used inside transactions excluded.
- */
-export type PrismaTransaction = Omit<PrismaClient, ITXClientDenyList>;
-
 /**
  * Type of data operation being performed.
  *
@@ -70,7 +71,7 @@ export interface TransactionalOperationContext<
   TConfig extends { hasResult: boolean },
 > extends OperationContext<TModel, TConfig> {
   /** Prisma transaction client for performing database operations */
-  tx: PrismaTransaction;
+  tx: Prisma.TransactionClient;
 }
 
 /**
@@ -166,22 +167,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 +221,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 +361,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>,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+> {
+  data: InferInput<TFields>;
+  query?: TIncludeArgs;
+  context: ServiceContext;
+}
+
+/**
+ * Input type for data service update functions.
+ */
+export interface DataUpdateInput<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+> {
+  where: WhereUniqueInput<TModelName>;
+  data: Partial<InferInput<TFields>>;
+  query?: TIncludeArgs;
+  context: ServiceContext;
+}
+
+/**
+ * Input type for data service delete functions.
+ */
+export interface DataDeleteInput<
+  TModelName extends ModelPropName,
+  TIncludeArgs extends ModelInclude<TModelName> = ModelInclude<TModelName>,
+> {
+  where: WhereUniqueInput<TModelName>;
+  query?: TIncludeArgs;
+  context: ServiceContext;
+}
+
+/**
+ * =========================================
+ * Commit Configs
+ * =========================================
+ */
+
+/**
+ * Configuration for `commitCreate`.
+ */
+export interface CommitCreateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TIncludeArgs extends ModelInclude<TModelName>,
+> {
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TIncludeArgs;
+
+  /**
+   * 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: TIncludeArgs,
+  ) => Promise<GetPayload<TModelName, TIncludeArgs>>;
+
+  /** Execute the Prisma create operation inside the transaction */
+  execute: (args: {
+    tx: Prisma.TransactionClient;
+    data: InferFieldsCreateOutput<TFields>;
+    query: ModelInclude<TModelName>;
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName, ModelInclude<TModelName>>>;
+}
+
+/**
+ * Configuration for `commitUpdate`.
+ */
+export interface CommitUpdateConfig<
+  TModelName extends ModelPropName,
+  TFields extends Record<string, AnyFieldDefinition>,
+  TIncludeArgs extends ModelInclude<TModelName>,
+> {
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TIncludeArgs;
+
+  /**
+   * 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: TIncludeArgs,
+  ) => Promise<GetPayload<TModelName, TIncludeArgs>>;
+
+  /** Execute the Prisma update operation inside the transaction */
+  execute: (args: {
+    tx: Prisma.TransactionClient;
+    data: InferFieldsUpdateOutput<TFields>;
+    query: ModelInclude<TModelName>;
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName, ModelInclude<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,
+  TIncludeArgs extends ModelInclude<TModelName>,
+> {
+  /** The Prisma model name */
+  model: TModelName;
+
+  /** Prisma query arguments (include) to shape returned data */
+  query?: TIncludeArgs;
+
+  /** 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: Prisma.TransactionClient;
+    query: ModelInclude<TModelName>;
+    serviceContext: ServiceContext;
+  }) => Promise<GetPayload<TModelName, ModelInclude<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"}

package/dist/generators/prisma/index.js

@@ -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.js.map

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

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

@@ -55,13 +55,24 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                 AnyOperationHooks: {
                     isTypeOnly: true;
                 };
+                commitCreate: {};
+                commitDelete: {};
+                commitUpdate: {};
+                composeCreate: {};
+                composeUpdate: {};
                 createParentModelConfig: {};
+                DataCreateInput: {
+                    isTypeOnly: true;
+                };
+                DataDeleteInput: {
+                    isTypeOnly: true;
+                };
                 DataOperationType: {
                     isTypeOnly: true;
                 };
-                defineCreateOperation: {};
-                defineDeleteOperation: {};
-                defineUpdateOperation: {};
+                DataUpdateInput: {
+                    isTypeOnly: true;
+                };
                 FieldContext: {
                     isTypeOnly: true;
                 };
@@ -74,6 +85,8 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                 FieldTransformResult: {
                     isTypeOnly: true;
                 };
+                generateCreateSchema: {};
+                generateUpdateSchema: {};
                 GetPayload: {
                     isTypeOnly: true;
                 };
@@ -83,6 +96,9 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                 InferInput: {
                     isTypeOnly: true;
                 };
+                ModelInclude: {
+                    isTypeOnly: true;
+                };
                 ModelPropName: {
                     isTypeOnly: true;
                 };
@@ -103,14 +119,17 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                 ParentModelConfig: {
                     isTypeOnly: true;
                 };
-                PrismaTransaction: {
-                    isTypeOnly: true;
-                };
                 relationHelpers: {};
                 scalarField: {};
                 TransactionalOperationContext: {
                     isTypeOnly: true;
                 };
+                WhereInput: {
+                    isTypeOnly: true;
+                };
+                WhereUniqueInput: {
+                    isTypeOnly: true;
+                };
             }>>;
             errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 BadRequestError: {};
@@ -156,13 +175,24 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                     AnyOperationHooks: {
                         isTypeOnly: true;
                     };
+                    commitCreate: {};
+                    commitDelete: {};
+                    commitUpdate: {};
+                    composeCreate: {};
+                    composeUpdate: {};
                     createParentModelConfig: {};
+                    DataCreateInput: {
+                        isTypeOnly: true;
+                    };
+                    DataDeleteInput: {
+                        isTypeOnly: true;
+                    };
                     DataOperationType: {
                         isTypeOnly: true;
                     };
-                    defineCreateOperation: {};
-                    defineDeleteOperation: {};
-                    defineUpdateOperation: {};
+                    DataUpdateInput: {
+                        isTypeOnly: true;
+                    };
                     FieldContext: {
                         isTypeOnly: true;
                     };
@@ -175,6 +205,8 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                     FieldTransformResult: {
                         isTypeOnly: true;
                     };
+                    generateCreateSchema: {};
+                    generateUpdateSchema: {};
                     GetPayload: {
                         isTypeOnly: true;
                     };
@@ -184,6 +216,9 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                     InferInput: {
                         isTypeOnly: true;
                     };
+                    ModelInclude: {
+                        isTypeOnly: true;
+                    };
                     ModelPropName: {
                         isTypeOnly: true;
                     };
@@ -204,14 +239,17 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                     ParentModelConfig: {
                         isTypeOnly: true;
                     };
-                    PrismaTransaction: {
-                        isTypeOnly: true;
-                    };
                     relationHelpers: {};
                     scalarField: {};
                     TransactionalOperationContext: {
                         isTypeOnly: true;
                     };
+                    WhereInput: {
+                        isTypeOnly: true;
+                    };
+                    WhereUniqueInput: {
+                        isTypeOnly: true;
+                    };
                 }>>;
                 errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                     BadRequestError: {};

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

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

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

@@ -29,13 +29,24 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_RENDERERS: {
             AnyOperationHooks: {
                 isTypeOnly: true;
             };
+            commitCreate: {};
+            commitDelete: {};
+            commitUpdate: {};
+            composeCreate: {};
+            composeUpdate: {};
             createParentModelConfig: {};
+            DataCreateInput: {
+                isTypeOnly: true;
+            };
+            DataDeleteInput: {
+                isTypeOnly: true;
+            };
             DataOperationType: {
                 isTypeOnly: true;
             };
-            defineCreateOperation: {};
-            defineDeleteOperation: {};
-            defineUpdateOperation: {};
+            DataUpdateInput: {
+                isTypeOnly: true;
+            };
             FieldContext: {
                 isTypeOnly: true;
             };
@@ -48,6 +59,8 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_RENDERERS: {
             FieldTransformResult: {
                 isTypeOnly: true;
             };
+            generateCreateSchema: {};
+            generateUpdateSchema: {};
             GetPayload: {
                 isTypeOnly: true;
             };
@@ -57,6 +70,9 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_RENDERERS: {
             InferInput: {
                 isTypeOnly: true;
             };
+            ModelInclude: {
+                isTypeOnly: true;
+            };
             ModelPropName: {
                 isTypeOnly: true;
             };
@@ -77,14 +93,17 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_RENDERERS: {
             ParentModelConfig: {
                 isTypeOnly: true;
             };
-            PrismaTransaction: {
-                isTypeOnly: true;
-            };
             relationHelpers: {};
             scalarField: {};
             TransactionalOperationContext: {
                 isTypeOnly: true;
             };
+            WhereInput: {
+                isTypeOnly: true;
+            };
+            WhereUniqueInput: {
+                isTypeOnly: true;
+            };
         }>>;
         errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             BadRequestError: {};

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

@@ -1 +1 @@
-{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-authorizer-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;AAWzD,OAAO,EAAE,wCAAwC,EAAE,MAAM,sBAAsB,CAAC;AAEhF,MAAM,WAAW,oCAAoC;IACnD,SAAS,EAAE;QACT,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,wCAAwC,CAAC,SAAS,CAC1D,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AAmDD,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpD,CAAC"}
+{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-authorizer-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;AAWzD,OAAO,EAAE,wCAAwC,EAAE,MAAM,sBAAsB,CAAC;AAEhF,MAAM,WAAW,oCAAoC;IACnD,SAAS,EAAE;QACT,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,wCAAwC,CAAC,SAAS,CAC1D,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AAmDD,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpD,CAAC"}