@baseplate-dev/fastify-generators 0.6.4 → 0.6.6

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

@@ -26,13 +26,13 @@ export type ModelPropName = Prisma.TypeMap['meta']['modelProps'];
  * @example
  * ```typescript
  * // Basic user type
- * type User = GetPayload<'user'>;
+ * type User = GetResult<'user'>;
  *
  * // User with posts included
- * type UserWithPosts = GetPayload<'user', { include: { posts: true } }>;
+ * type UserWithPosts = GetResult<'user', { include: { posts: true } }>;
  * ```
  */
-export type GetPayload<
+export type GetResult<
   TModelName extends ModelPropName,
   TIncludeArgs = undefined,
 > = Result<
@@ -49,18 +49,18 @@ export type GetPayload<
  * Used to shape the returned data from database operations by specifying
  * which relations to include. Only `include` is supported; `select` is
  * accepted as `undefined` for compatibility with `queryFromInfo()` but
- * will be stripped by `GetPayload`.
+ * will be stripped by `GetResult`.
  *
  * @template TModelName - The Prisma model name
  *
  * @example
  * ```typescript
- * const query: ModelInclude<'user'> = {
+ * const query: DataQuery<'user'> = {
  *   include: { posts: true, profile: true },
  * };
  * ```
  */
-export type ModelInclude<TModelName extends ModelPropName> = {
+export type DataQuery<TModelName extends ModelPropName> = {
   select?: undefined;
 } & Pick<
   Args<(typeof prisma)[TModelName], 'findUnique'> extends { include?: infer I }
@@ -89,80 +89,3 @@ 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/transformer-types.ts

@@ -0,0 +1,118 @@
+// @ts-nocheck
+
+import type { Prisma } from '%prismaGeneratedImports';
+import type { ServiceContext } from '%serviceContextImports';
+
+/* eslint-disable @typescript-eslint/no-explicit-any -- generic type utilities */
+
+/** A value that may or may not be wrapped in a Promise */
+export type MaybePromise<T> = T | Promise<T>;
+
+/** Hook that runs inside a transaction after the main operation */
+export type AfterExecuteHook = (ctx: {
+  tx: Prisma.TransactionClient;
+  result: unknown;
+}) => Promise<void>;
+
+/**
+ * Result of processing a bound transformer.
+ *
+ * @template TOutput - The Prisma-compatible data type this transformer produces
+ */
+export interface TransformerResult<TOutput> {
+  /** Transformed data, or a deferred function that produces data inside a transaction */
+  data?: TOutput | ((tx: Prisma.TransactionClient) => Promise<TOutput>);
+  /** Hooks to run inside the transaction after the main operation */
+  afterExecute?: AfterExecuteHook[];
+}
+
+/**
+ * A fully-bound transformer ready to be processed.
+ *
+ * Created by calling `.forCreate(input, ...args)` or `.forUpdate(input, ...args)`
+ * on a `Transformer`. The input value and context are already captured — `process`
+ * only needs the service context.
+ *
+ * @template TOutput - The Prisma-compatible data type this transformer produces
+ */
+export interface BoundTransformer<TOutput> {
+  /** Process the bound input and produce Prisma data + optional hooks */
+  process(ctx: {
+    serviceContext: ServiceContext;
+  }): MaybePromise<TransformerResult<TOutput>>;
+}
+
+/** Type alias for any bound transformer (used for generic constraints) */
+export type AnyBoundTransformer = BoundTransformer<any>;
+
+/**
+ * A reusable transformer definition with `.forCreate()` and `.forUpdate()` methods.
+ *
+ * Transformers handle complex field processing that goes beyond simple Zod validation:
+ * file uploads, nested entity orchestration, state machine transitions, etc.
+ *
+ * @template TInput - The input value type
+ * @template TCreateArgs - Tuple of additional args for `.forCreate()` (empty `[]` = no extra args)
+ * @template TUpdateArgs - Tuple of additional args for `.forUpdate()` (e.g., `[existing: string | null]`)
+ * @template TCreateOutput - Prisma data type for create operations
+ * @template TUpdateOutput - Prisma data type for update operations
+ */
+export interface Transformer<
+  TInput,
+  TCreateArgs extends unknown[],
+  TUpdateArgs extends unknown[],
+  TCreateOutput,
+  TUpdateOutput,
+> {
+  /** Bind for a create operation. Takes the input value + any create-specific args. */
+  forCreate(
+    input: TInput,
+    ...args: TCreateArgs
+  ): BoundTransformer<TCreateOutput>;
+  /** Bind for an update operation. Takes the input value (or undefined for partial) + any update-specific args. */
+  forUpdate(
+    input: TInput | undefined,
+    ...args: TUpdateArgs
+  ): BoundTransformer<TUpdateOutput>;
+}
+
+/** Type alias for any transformer (used for generic constraints) */
+export type AnyTransformer = Transformer<any, any[], any[], any, any>;
+
+/** Infer the output type of a bound transformer */
+type InferBoundOutput<T extends AnyBoundTransformer> =
+  T extends BoundTransformer<infer TOutput> ? TOutput : never;
+
+/** The shape of a transformer's data before resolution: either a plain value or a deferred function */
+type DeferredOrValue<T> = T | ((tx: Prisma.TransactionClient) => Promise<T>);
+
+/** Infer the unresolved (pre-transaction) data map from a record of bound transformers */
+export type InferUnresolvedTransformed<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+> = {
+  [K in keyof TTransformers]: DeferredOrValue<
+    InferBoundOutput<TTransformers[K]>
+  >;
+};
+
+/** Infer the resolved transformed data map from a record of bound transformers */
+export type InferTransformed<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+> = {
+  [K in keyof TTransformers]: InferBoundOutput<TTransformers[K]>;
+};
+
+/**
+ * The result of `prepareTransformers`. Contains unresolved transformer data
+ * (which may include deferred functions) and collected afterExecute hooks.
+ *
+ * @template TTransformers - Record of bound transformers
+ */
+export interface TransformPlan<
+  TTransformers extends Record<string, AnyBoundTransformer>,
+> {
+  /** Unresolved data from each transformer — may contain deferred functions */
+  transformed: InferUnresolvedTransformed<TTransformers>;
+  /** Collected afterExecute hooks from all transformers */
+  afterExecute: AfterExecuteHook[];
+}

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

@@ -49,87 +49,51 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                 };
             }>>;
             dataUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
-                AnyFieldDefinition: {
+                AfterExecuteHook: {
                     isTypeOnly: true;
                 };
-                AnyOperationHooks: {
+                AnyBoundTransformer: {
                     isTypeOnly: true;
                 };
-                commitCreate: {};
-                commitDelete: {};
-                commitUpdate: {};
-                composeCreate: {};
-                composeUpdate: {};
-                createParentModelConfig: {};
-                DataCreateInput: {
+                AnyTransformer: {
                     isTypeOnly: true;
                 };
-                DataDeleteInput: {
+                BoundTransformer: {
                     isTypeOnly: true;
                 };
-                DataOperationType: {
+                DataQuery: {
                     isTypeOnly: true;
                 };
-                DataUpdateInput: {
+                defineTransformer: {};
+                executeTransformPlan: {};
+                GetResult: {
                     isTypeOnly: true;
                 };
-                FieldContext: {
+                InferTransformed: {
                     isTypeOnly: true;
                 };
-                FieldDefinition: {
-                    isTypeOnly: true;
-                };
-                FieldTransformData: {
-                    isTypeOnly: true;
-                };
-                FieldTransformResult: {
-                    isTypeOnly: true;
-                };
-                generateCreateSchema: {};
-                generateUpdateSchema: {};
-                GetPayload: {
-                    isTypeOnly: true;
-                };
-                InferFieldsOutput: {
-                    isTypeOnly: true;
-                };
-                InferInput: {
-                    isTypeOnly: true;
-                };
-                ModelInclude: {
+                MaybePromise: {
                     isTypeOnly: true;
                 };
                 ModelPropName: {
                     isTypeOnly: true;
                 };
-                nestedOneToManyField: {};
-                NestedOneToManyFieldConfig: {
-                    isTypeOnly: true;
-                };
-                nestedOneToOneField: {};
-                NestedOneToOneFieldConfig: {
-                    isTypeOnly: true;
-                };
-                OperationContext: {
-                    isTypeOnly: true;
-                };
-                OperationHooks: {
+                oneToManyTransformer: {};
+                oneToOneTransformer: {};
+                prepareTransformers: {};
+                relationHelpers: {};
+                Transformer: {
                     isTypeOnly: true;
                 };
-                ParentModelConfig: {
+                TransformerResult: {
                     isTypeOnly: true;
                 };
-                relationHelpers: {};
-                scalarField: {};
-                TransactionalOperationContext: {
+                TransformPlan: {
                     isTypeOnly: true;
                 };
                 WhereInput: {
                     isTypeOnly: true;
                 };
-                WhereUniqueInput: {
-                    isTypeOnly: true;
-                };
             }>>;
             errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 BadRequestError: {};
@@ -169,87 +133,51 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_GENERATED: {
                     };
                 }>>;
                 dataUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
-                    AnyFieldDefinition: {
+                    AfterExecuteHook: {
                         isTypeOnly: true;
                     };
-                    AnyOperationHooks: {
+                    AnyBoundTransformer: {
                         isTypeOnly: true;
                     };
-                    commitCreate: {};
-                    commitDelete: {};
-                    commitUpdate: {};
-                    composeCreate: {};
-                    composeUpdate: {};
-                    createParentModelConfig: {};
-                    DataCreateInput: {
+                    AnyTransformer: {
                         isTypeOnly: true;
                     };
-                    DataDeleteInput: {
+                    BoundTransformer: {
                         isTypeOnly: true;
                     };
-                    DataOperationType: {
+                    DataQuery: {
                         isTypeOnly: true;
                     };
-                    DataUpdateInput: {
+                    defineTransformer: {};
+                    executeTransformPlan: {};
+                    GetResult: {
                         isTypeOnly: true;
                     };
-                    FieldContext: {
+                    InferTransformed: {
                         isTypeOnly: true;
                     };
-                    FieldDefinition: {
-                        isTypeOnly: true;
-                    };
-                    FieldTransformData: {
-                        isTypeOnly: true;
-                    };
-                    FieldTransformResult: {
-                        isTypeOnly: true;
-                    };
-                    generateCreateSchema: {};
-                    generateUpdateSchema: {};
-                    GetPayload: {
-                        isTypeOnly: true;
-                    };
-                    InferFieldsOutput: {
-                        isTypeOnly: true;
-                    };
-                    InferInput: {
-                        isTypeOnly: true;
-                    };
-                    ModelInclude: {
+                    MaybePromise: {
                         isTypeOnly: true;
                     };
                     ModelPropName: {
                         isTypeOnly: true;
                     };
-                    nestedOneToManyField: {};
-                    NestedOneToManyFieldConfig: {
-                        isTypeOnly: true;
-                    };
-                    nestedOneToOneField: {};
-                    NestedOneToOneFieldConfig: {
-                        isTypeOnly: true;
-                    };
-                    OperationContext: {
-                        isTypeOnly: true;
-                    };
-                    OperationHooks: {
+                    oneToManyTransformer: {};
+                    oneToOneTransformer: {};
+                    prepareTransformers: {};
+                    relationHelpers: {};
+                    Transformer: {
                         isTypeOnly: true;
                     };
-                    ParentModelConfig: {
+                    TransformerResult: {
                         isTypeOnly: true;
                     };
-                    relationHelpers: {};
-                    scalarField: {};
-                    TransactionalOperationContext: {
+                    TransformPlan: {
                         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

@@ -23,87 +23,51 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_RENDERERS: {
             };
         }>>;
         dataUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
-            AnyFieldDefinition: {
+            AfterExecuteHook: {
                 isTypeOnly: true;
             };
-            AnyOperationHooks: {
+            AnyBoundTransformer: {
                 isTypeOnly: true;
             };
-            commitCreate: {};
-            commitDelete: {};
-            commitUpdate: {};
-            composeCreate: {};
-            composeUpdate: {};
-            createParentModelConfig: {};
-            DataCreateInput: {
+            AnyTransformer: {
                 isTypeOnly: true;
             };
-            DataDeleteInput: {
+            BoundTransformer: {
                 isTypeOnly: true;
             };
-            DataOperationType: {
+            DataQuery: {
                 isTypeOnly: true;
             };
-            DataUpdateInput: {
+            defineTransformer: {};
+            executeTransformPlan: {};
+            GetResult: {
                 isTypeOnly: true;
             };
-            FieldContext: {
+            InferTransformed: {
                 isTypeOnly: true;
             };
-            FieldDefinition: {
-                isTypeOnly: true;
-            };
-            FieldTransformData: {
-                isTypeOnly: true;
-            };
-            FieldTransformResult: {
-                isTypeOnly: true;
-            };
-            generateCreateSchema: {};
-            generateUpdateSchema: {};
-            GetPayload: {
-                isTypeOnly: true;
-            };
-            InferFieldsOutput: {
-                isTypeOnly: true;
-            };
-            InferInput: {
-                isTypeOnly: true;
-            };
-            ModelInclude: {
+            MaybePromise: {
                 isTypeOnly: true;
             };
             ModelPropName: {
                 isTypeOnly: true;
             };
-            nestedOneToManyField: {};
-            NestedOneToManyFieldConfig: {
-                isTypeOnly: true;
-            };
-            nestedOneToOneField: {};
-            NestedOneToOneFieldConfig: {
-                isTypeOnly: true;
-            };
-            OperationContext: {
-                isTypeOnly: true;
-            };
-            OperationHooks: {
+            oneToManyTransformer: {};
+            oneToOneTransformer: {};
+            prepareTransformers: {};
+            relationHelpers: {};
+            Transformer: {
                 isTypeOnly: true;
             };
-            ParentModelConfig: {
+            TransformerResult: {
                 isTypeOnly: true;
             };
-            relationHelpers: {};
-            scalarField: {};
-            TransactionalOperationContext: {
+            TransformPlan: {
                 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"}