@baseplate-dev/fastify-generators 0.6.4 → 0.6.5

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

@@ -12,87 +12,51 @@ export declare const mainGroup: {
             };
         }>>;
         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: {};
@@ -130,87 +94,51 @@ export declare const PRISMA_PRISMA_AUTHORIZER_UTILS_TEMPLATES: {
                 };
             }>>;
             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/typed-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-authorizer-utils/generated/typed-templates.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuB,CAAC;AAE9C,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgB,CAAC"}
+{"version":3,"file":"typed-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-authorizer-utils/generated/typed-templates.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuB,CAAC;AAE9C,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgB,CAAC"}

package/dist/generators/prisma/prisma-authorizer-utils/prisma-authorizer-utils.generator.d.ts

@@ -45,87 +45,51 @@ export declare const prismaAuthorizerUtilsGenerator: import("@baseplate-dev/sync
             };
         }>>;
         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/prisma-authorizer-utils.generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma-authorizer-utils.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-authorizer-utils/prisma-authorizer-utils.generator.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCzC,CAAC"}
+{"version":3,"file":"prisma-authorizer-utils.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-authorizer-utils/prisma-authorizer-utils.generator.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCzC,CAAC"}

package/dist/generators/prisma/prisma-authorizer-utils/templates/src/utils/authorizers.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 
 import type { AuthRole } from '%authRolesImports';
-import type { GetPayload, ModelPropName } from '%dataUtilsImports';
+import type { GetResult, ModelPropName } from '%dataUtilsImports';
 import type { ServiceContext } from '%serviceContextImports';
 
 import { ForbiddenError } from '%errorHandlerServiceImports';
@@ -121,16 +121,16 @@ export async function checkInstanceAuthorization<T>(
  */
 export interface ModelAuthorizerConfig<
   TModelName extends ModelPropName,
-  TRoles extends Record<string, InstanceRoleCheck<GetPayload<TModelName>>>,
+  TRoles extends Record<string, InstanceRoleCheck<GetResult<TModelName>>>,
 > {
   /** Prisma model name */
   model: TModelName;
 
   /** Field used as the primary key */
-  idField: keyof GetPayload<TModelName>;
+  idField: keyof GetResult<TModelName>;
 
   /** Function to load model by ID */
-  getModelById: (id: string) => Promise<GetPayload<TModelName> | null>;
+  getModelById: (id: string) => Promise<GetResult<TModelName> | null>;
 
   /** Role check functions - "who you are" relative to this resource */
   roles: TRoles;
@@ -141,7 +141,7 @@ export interface ModelAuthorizerConfig<
  */
 export interface ModelAuthorizer<
   TModelName extends ModelPropName,
-  TRoles extends Record<string, InstanceRoleCheck<GetPayload<TModelName>>>,
+  TRoles extends Record<string, InstanceRoleCheck<GetResult<TModelName>>>,
 > {
   /** The model name */
   readonly model: TModelName;
@@ -163,7 +163,7 @@ export interface ModelAuthorizer<
    */
   hasRole(
     ctx: ServiceContext,
-    model: GetPayload<TModelName>,
+    model: GetResult<TModelName>,
     role: keyof TRoles,
   ): Promise<boolean>;
 
@@ -199,7 +199,7 @@ export interface ModelAuthorizer<
  */
 export function createModelAuthorizer<
   TModelName extends ModelPropName,
-  TRoles extends Record<string, InstanceRoleCheck<GetPayload<TModelName>>>,
+  TRoles extends Record<string, InstanceRoleCheck<GetResult<TModelName>>>,
 >(
   config: ModelAuthorizerConfig<TModelName, TRoles>,
 ): ModelAuthorizer<TModelName, TRoles> {
@@ -211,7 +211,7 @@ export function createModelAuthorizer<
     return `authz:${config.model}:model:${id}`;
   }
 
-  function getIdFromModel(model: GetPayload<TModelName>): string | number {
+  function getIdFromModel(model: GetResult<TModelName>): string | number {
     const id = model[config.idField];
     if (typeof id !== 'string' && typeof id !== 'number') {
       throw new TypeError(
@@ -223,7 +223,7 @@ export function createModelAuthorizer<
 
   function getRoleCheck(
     role: keyof TRoles,
-  ): InstanceRoleCheck<GetPayload<TModelName>> {
+  ): InstanceRoleCheck<GetResult<TModelName>> {
     if (!(role in config.roles)) {
       throw new Error(`Role ${String(role)} not found`);
     }
@@ -236,7 +236,7 @@ export function createModelAuthorizer<
 
   async function hasRoleWithModel(
     ctx: ServiceContext,
-    model: GetPayload<TModelName>,
+    model: GetResult<TModelName>,
     role: keyof TRoles,
   ): Promise<boolean> {
     const id = getIdFromModel(model);
@@ -273,7 +273,7 @@ export function createModelAuthorizer<
     // Check model cache or load model
     const modelCacheKey = getModelCacheKey(id);
     let model = ctx.authorizerModelCache.get(modelCacheKey) as
-      | GetPayload<TModelName>
+      | GetResult<TModelName>
       | null
       | undefined;
 

package/dist/generators/prisma/prisma-data-create/prisma-data-create.generator.d.ts

@@ -1,5 +1,10 @@
 /**
  * Generator for prisma/prisma-data-create
+ *
+ * Generates a create function that:
+ * - Checks authorization (global only for creates)
+ * - For scalar-only models: calls prisma.model.create directly
+ * - For models with transformers: uses prepareTransformers + executeTransformPlan
  */
 export declare const prismaDataCreateGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
     name: string;
@@ -11,89 +16,74 @@ export declare const prismaDataCreateGenerator: import("@baseplate-dev/sync").Ge
         serviceFile: import("@baseplate-dev/sync").ProviderType<import("#src/generators/core/index.js").ServiceFileProvider>;
         prismaDataService: import("@baseplate-dev/sync").ProviderType<import("../prisma-data-service/prisma-data-service.generator.js").PrismaDataServiceProvider>;
         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: {
+            oneToManyTransformer: {};
+            oneToOneTransformer: {};
+            prepareTransformers: {};
+            relationHelpers: {};
+            Transformer: {
                 isTypeOnly: true;
             };
-            OperationContext: {
+            TransformerResult: {
                 isTypeOnly: true;
             };
-            OperationHooks: {
+            TransformPlan: {
                 isTypeOnly: true;
             };
-            ParentModelConfig: {
+            WhereInput: {
                 isTypeOnly: true;
             };
-            relationHelpers: {};
-            scalarField: {};
-            TransactionalOperationContext: {
+        }>>;
+        prismaOutput: import("@baseplate-dev/sync").ProviderType<import("../prisma/prisma.generator.js").PrismaOutputProvider>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+        authorizerImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            checkGlobalAuthorization: {};
+            checkInstanceAuthorization: {};
+            GlobalRoleCheck: {
                 isTypeOnly: true;
             };
-            WhereInput: {
+            InstanceRoleCheck: {
                 isTypeOnly: true;
             };
-            WhereUniqueInput: {
+        }>>;
+        serviceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createServiceContext: {};
+            createSystemServiceContext: {};
+            createTestServiceContext: {};
+            ServiceContext: {
                 isTypeOnly: true;
             };
         }>>;
-        prismaOutput: import("@baseplate-dev/sync").ProviderType<import("../prisma/prisma.generator.js").PrismaOutputProvider>;
     }, any>;
 }>;
 //# sourceMappingURL=prisma-data-create.generator.d.ts.map

package/dist/generators/prisma/prisma-data-create/prisma-data-create.generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma-data-create.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-data-create/prisma-data-create.generator.ts"],"names":[],"mappings":"AAoCA;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuIpC,CAAC"}
+{"version":3,"file":"prisma-data-create.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-data-create/prisma-data-create.generator.ts"],"names":[],"mappings":"AAkCA;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8KpC,CAAC"}