@baseplate-dev/fastify-generators 0.1.1

package/dist/generators/prisma/prisma-relation-field/prisma-relation-field.generator.d.ts

@@ -0,0 +1,19 @@
+export declare const prismaRelationFieldGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    fields: string[];
+    name: string;
+    references: string[];
+    modelName: string;
+    foreignModelName: string;
+    optional?: boolean | undefined;
+    foreignRelationName?: string | undefined;
+    relationshipName?: string | undefined;
+    relationshipType?: "oneToOne" | "oneToMany" | undefined;
+    onDelete?: "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault" | undefined;
+    onUpdate?: "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault" | undefined;
+}, {
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        prismaModel: import("@baseplate-dev/sync").ProviderDependency<import("../prisma-model/prisma-model.generator.js").PrismaModelProvider>;
+        foreignModel: import("@baseplate-dev/sync").ProviderDependency<import("../prisma-model/prisma-model.generator.js").PrismaModelProvider>;
+    }, any>;
+}>;
+//# sourceMappingURL=prisma-relation-field.generator.d.ts.map

package/dist/generators/prisma/prisma-relation-field/prisma-relation-field.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-relation-field.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-relation-field/prisma-relation-field.generator.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;EAqEvC,CAAC"}

package/dist/generators/prisma/prisma-relation-field/prisma-relation-field.generator.js

@@ -0,0 +1,81 @@
+import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { doubleQuot } from '#src/utils/string.js';
+import { prismaModelProvider } from '../prisma-model/prisma-model.generator.js';
+const REFERENTIAL_ACTIONS = [
+    'Cascade',
+    'Restrict',
+    'NoAction',
+    'SetNull',
+    'SetDefault',
+];
+const descriptorSchema = z.object({
+    name: z.string().min(1),
+    fields: z.array(z.string().min(1)),
+    references: z.array(z.string().min(1)),
+    modelName: z.string().min(1),
+    foreignModelName: z.string().min(1),
+    foreignRelationName: z.string().optional(),
+    relationshipName: z.string().optional(),
+    relationshipType: z.enum(['oneToOne', 'oneToMany']).default('oneToMany'),
+    optional: z.boolean().default(false),
+    onDelete: z.enum(REFERENTIAL_ACTIONS).default('Cascade'),
+    onUpdate: z.enum(REFERENTIAL_ACTIONS).default('Restrict'),
+});
+export const prismaRelationFieldGenerator = createGenerator({
+    name: 'prisma/prisma-relation-field',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    getInstanceName: (descriptor) => descriptor.name,
+    buildTasks: (descriptor) => ({
+        main: createGeneratorTask({
+            dependencies: {
+                prismaModel: prismaModelProvider
+                    .dependency()
+                    .reference(descriptor.modelName),
+                foreignModel: prismaModelProvider
+                    .dependency()
+                    .reference(descriptor.foreignModelName),
+            },
+            run({ prismaModel, foreignModel }) {
+                const { name, fields, references, foreignRelationName, relationshipName, relationshipType, optional, onDelete, onUpdate, } = descriptor;
+                const isManyToOne = relationshipType === 'oneToMany';
+                const modelName = foreignModel.getName();
+                prismaModel.addField({
+                    name,
+                    type: modelName,
+                    fieldType: 'relation',
+                    isOptional: optional,
+                    attributes: [
+                        {
+                            name: '@relation',
+                            args: [
+                                ...(relationshipName ? [doubleQuot(relationshipName)] : []),
+                                {
+                                    fields,
+                                    references,
+                                    onDelete,
+                                    onUpdate,
+                                },
+                            ],
+                        },
+                    ],
+                });
+                if (foreignRelationName) {
+                    foreignModel.addField({
+                        name: foreignRelationName,
+                        type: prismaModel.getName(),
+                        isList: isManyToOne,
+                        isOptional: !isManyToOne,
+                        fieldType: 'relation',
+                        attributes: relationshipName
+                            ? [{ name: '@relation', args: [doubleQuot(relationshipName)] }]
+                            : [],
+                    });
+                }
+                return {};
+            },
+        }),
+    }),
+});
+//# sourceMappingURL=prisma-relation-field.generator.js.map

package/dist/generators/prisma/prisma-relation-field/prisma-relation-field.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-relation-field.generator.js","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-relation-field/prisma-relation-field.generator.ts"],"names":[],"mappings":"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"}

package/dist/generators/prisma/prisma-utils/generated/ts-import-maps.d.ts

@@ -0,0 +1,57 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+declare const prismaUtilsImportsSchema: {
+    applyDataPipeOutput: {};
+    applyDataPipeOutputToOperations: {};
+    applyDataPipeOutputWithoutOperation: {};
+    createOneToManyCreateData: {};
+    createOneToManyUpsertData: {};
+    createOneToOneCreateData: {};
+    createOneToOneUpsertData: {};
+    createPrismaDisconnectOrConnectData: {};
+    CreateServiceInput: {
+        isTypeOnly: true;
+    };
+    DataPipeOutput: {
+        isTypeOnly: true;
+    };
+    DeleteServiceInput: {
+        isTypeOnly: true;
+    };
+    mergePipeOperations: {};
+    UpdateServiceInput: {
+        isTypeOnly: true;
+    };
+    UpsertPayload: {
+        isTypeOnly: true;
+    };
+};
+export type PrismaUtilsImportsProvider = TsImportMapProviderFromSchema<typeof prismaUtilsImportsSchema>;
+export declare const prismaUtilsImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    applyDataPipeOutput: {};
+    applyDataPipeOutputToOperations: {};
+    applyDataPipeOutputWithoutOperation: {};
+    createOneToManyCreateData: {};
+    createOneToManyUpsertData: {};
+    createOneToOneCreateData: {};
+    createOneToOneUpsertData: {};
+    createPrismaDisconnectOrConnectData: {};
+    CreateServiceInput: {
+        isTypeOnly: true;
+    };
+    DataPipeOutput: {
+        isTypeOnly: true;
+    };
+    DeleteServiceInput: {
+        isTypeOnly: true;
+    };
+    mergePipeOperations: {};
+    UpdateServiceInput: {
+        isTypeOnly: true;
+    };
+    UpsertPayload: {
+        isTypeOnly: true;
+    };
+}>>;
+export declare function createPrismaUtilsImports(importBase: string): PrismaUtilsImportsProvider;
+export {};
+//# sourceMappingURL=ts-import-maps.d.ts.map

package/dist/generators/prisma/prisma-utils/generated/ts-import-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-utils/generated/ts-import-maps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AASpF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;CAe5B,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,6BAA6B,CACpE,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;GAGpC,CAAC;AAEJ,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,GACjB,0BAA0B,CAoC5B"}

package/dist/generators/prisma/prisma-utils/generated/ts-import-maps.js

@@ -0,0 +1,42 @@
+import { createTsImportMap, createTsImportMapSchema, } from '@baseplate-dev/core-generators';
+import { createReadOnlyProviderType } from '@baseplate-dev/sync';
+import path from 'node:path/posix';
+const prismaUtilsImportsSchema = createTsImportMapSchema({
+    applyDataPipeOutput: {},
+    applyDataPipeOutputToOperations: {},
+    applyDataPipeOutputWithoutOperation: {},
+    createOneToManyCreateData: {},
+    createOneToManyUpsertData: {},
+    createOneToOneCreateData: {},
+    createOneToOneUpsertData: {},
+    createPrismaDisconnectOrConnectData: {},
+    CreateServiceInput: { isTypeOnly: true },
+    DataPipeOutput: { isTypeOnly: true },
+    DeleteServiceInput: { isTypeOnly: true },
+    mergePipeOperations: {},
+    UpdateServiceInput: { isTypeOnly: true },
+    UpsertPayload: { isTypeOnly: true },
+});
+export const prismaUtilsImportsProvider = createReadOnlyProviderType('prisma-utils-imports');
+export function createPrismaUtilsImports(importBase) {
+    if (!importBase.startsWith('@/')) {
+        throw new Error('importBase must start with @/');
+    }
+    return createTsImportMap(prismaUtilsImportsSchema, {
+        applyDataPipeOutput: path.join(importBase, 'data-pipes.js'),
+        applyDataPipeOutputToOperations: path.join(importBase, 'data-pipes.js'),
+        applyDataPipeOutputWithoutOperation: path.join(importBase, 'data-pipes.js'),
+        createOneToManyCreateData: path.join(importBase, 'embedded-pipes/embedded-one-to-many.js'),
+        createOneToManyUpsertData: path.join(importBase, 'embedded-pipes/embedded-one-to-many.js'),
+        createOneToOneCreateData: path.join(importBase, 'embedded-pipes/embedded-one-to-one.js'),
+        createOneToOneUpsertData: path.join(importBase, 'embedded-pipes/embedded-one-to-one.js'),
+        createPrismaDisconnectOrConnectData: path.join(importBase, 'prisma-relations.js'),
+        CreateServiceInput: path.join(importBase, 'crud-service-types.js'),
+        DataPipeOutput: path.join(importBase, 'data-pipes.js'),
+        DeleteServiceInput: path.join(importBase, 'crud-service-types.js'),
+        mergePipeOperations: path.join(importBase, 'data-pipes.js'),
+        UpdateServiceInput: path.join(importBase, 'crud-service-types.js'),
+        UpsertPayload: path.join(importBase, 'embedded-pipes/embedded-types.js'),
+    });
+}
+//# sourceMappingURL=ts-import-maps.js.map

package/dist/generators/prisma/prisma-utils/generated/ts-import-maps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.js","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-utils/generated/ts-import-maps.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;IACvD,mBAAmB,EAAE,EAAE;IACvB,+BAA+B,EAAE,EAAE;IACnC,mCAAmC,EAAE,EAAE;IACvC,yBAAyB,EAAE,EAAE;IAC7B,yBAAyB,EAAE,EAAE;IAC7B,wBAAwB,EAAE,EAAE;IAC5B,wBAAwB,EAAE,EAAE;IAC5B,mCAAmC,EAAE,EAAE;IACvC,kBAAkB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACxC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACpC,kBAAkB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACxC,mBAAmB,EAAE,EAAE;IACvB,kBAAkB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACxC,aAAa,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;CACpC,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,0BAA0B,GACrC,0BAA0B,CACxB,sBAAsB,CACvB,CAAC;AAEJ,MAAM,UAAU,wBAAwB,CACtC,UAAkB;IAElB,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,iBAAiB,CAAC,wBAAwB,EAAE;QACjD,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC;QAC3D,+BAA+B,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC;QACvE,mCAAmC,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC;QAC3E,yBAAyB,EAAE,IAAI,CAAC,IAAI,CAClC,UAAU,EACV,wCAAwC,CACzC;QACD,yBAAyB,EAAE,IAAI,CAAC,IAAI,CAClC,UAAU,EACV,wCAAwC,CACzC;QACD,wBAAwB,EAAE,IAAI,CAAC,IAAI,CACjC,UAAU,EACV,uCAAuC,CACxC;QACD,wBAAwB,EAAE,IAAI,CAAC,IAAI,CACjC,UAAU,EACV,uCAAuC,CACxC;QACD,mCAAmC,EAAE,IAAI,CAAC,IAAI,CAC5C,UAAU,EACV,qBAAqB,CACtB;QACD,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,uBAAuB,CAAC;QAClE,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC;QACtD,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,uBAAuB,CAAC;QAClE,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC;QAC3D,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,uBAAuB,CAAC;QAClE,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,kCAAkC,CAAC;KACzE,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,73 @@
+export declare const PRISMA_PRISMA_UTILS_TS_TEMPLATES: {
+    utilsGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        crudServiceTypes: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                serviceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createServiceContext: {};
+                    createTestServiceContext: {};
+                    ServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }>;
+        };
+        dataPipes: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    prisma: {};
+                }>>;
+                tsUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    capitalizeString: {};
+                    NormalizeTypes: {
+                        isTypeOnly: true;
+                    };
+                    notEmpty: {};
+                    restrictObjectNulls: {};
+                }>>;
+            }>;
+        };
+        embeddedOneToMany: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                serviceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createServiceContext: {};
+                    createTestServiceContext: {};
+                    ServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+                tsUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    capitalizeString: {};
+                    NormalizeTypes: {
+                        isTypeOnly: true;
+                    };
+                    notEmpty: {};
+                    restrictObjectNulls: {};
+                }>>;
+            }>;
+        };
+        embeddedOneToOne: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                serviceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createServiceContext: {};
+                    createTestServiceContext: {};
+                    ServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }>;
+        };
+        embeddedTypes: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, Record<never, import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/sync").Provider>>>;
+        };
+        prismaRelations: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, Record<never, import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/sync").Provider>>>;
+        };
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-utils/generated/ts-templates.ts"],"names":[],"mappings":"AA6GA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiB,CAAC"}

package/dist/generators/prisma/prisma-utils/generated/ts-templates.js

@@ -0,0 +1,98 @@
+import { createTsTemplateFile, createTsTemplateGroup, tsUtilsImportsProvider, } from '@baseplate-dev/core-generators';
+import { serviceContextImportsProvider } from '../../../core/service-context/generated/ts-import-maps.js';
+import { prismaImportsProvider } from '../../prisma/generated/ts-import-maps.js';
+const crudServiceTypes = createTsTemplateFile({
+    group: 'utils',
+    importMapProviders: { serviceContextImports: serviceContextImportsProvider },
+    name: 'crud-service-types',
+    projectExports: {
+        CreateServiceInput: { isTypeOnly: true },
+        DeleteServiceInput: { isTypeOnly: true },
+        UpdateServiceInput: { isTypeOnly: true },
+    },
+    source: { path: 'crud-service-types.ts' },
+    variables: {},
+});
+const dataPipes = createTsTemplateFile({
+    group: 'utils',
+    importMapProviders: {
+        prismaImports: prismaImportsProvider,
+        tsUtilsImports: tsUtilsImportsProvider,
+    },
+    name: 'data-pipes',
+    projectExports: {
+        DataPipeOutput: { isTypeOnly: true },
+        applyDataPipeOutput: {},
+        applyDataPipeOutputToOperations: {},
+        applyDataPipeOutputWithoutOperation: {},
+        mergePipeOperations: {},
+    },
+    source: { path: 'data-pipes.ts' },
+    variables: {},
+});
+const embeddedOneToMany = createTsTemplateFile({
+    group: 'utils',
+    importMapProviders: {
+        serviceContextImports: serviceContextImportsProvider,
+        tsUtilsImports: tsUtilsImportsProvider,
+    },
+    name: 'embedded-one-to-many',
+    projectExports: {
+        createOneToManyCreateData: {},
+        createOneToManyUpsertData: {},
+    },
+    source: { path: 'embedded-pipes/embedded-one-to-many.ts' },
+    variables: {},
+});
+const embeddedOneToOne = createTsTemplateFile({
+    group: 'utils',
+    importMapProviders: { serviceContextImports: serviceContextImportsProvider },
+    name: 'embedded-one-to-one',
+    projectExports: {
+        createOneToOneCreateData: {},
+        createOneToOneUpsertData: {},
+    },
+    source: { path: 'embedded-pipes/embedded-one-to-one.ts' },
+    variables: {},
+});
+const embeddedTypes = createTsTemplateFile({
+    group: 'utils',
+    name: 'embedded-types',
+    projectExports: { UpsertPayload: { isTypeOnly: true } },
+    source: { path: 'embedded-pipes/embedded-types.ts' },
+    variables: {},
+});
+const prismaRelations = createTsTemplateFile({
+    group: 'utils',
+    name: 'prisma-relations',
+    projectExports: { createPrismaDisconnectOrConnectData: {} },
+    source: { path: 'prisma-relations.ts' },
+    variables: {},
+});
+const utilsGroup = createTsTemplateGroup({
+    templates: {
+        crudServiceTypes: {
+            destination: 'crud-service-types.ts',
+            template: crudServiceTypes,
+        },
+        dataPipes: { destination: 'data-pipes.ts', template: dataPipes },
+        embeddedOneToMany: {
+            destination: 'embedded-pipes/embedded-one-to-many.ts',
+            template: embeddedOneToMany,
+        },
+        embeddedOneToOne: {
+            destination: 'embedded-pipes/embedded-one-to-one.ts',
+            template: embeddedOneToOne,
+        },
+        embeddedTypes: {
+            destination: 'embedded-pipes/embedded-types.ts',
+            template: embeddedTypes,
+        },
+        prismaRelations: {
+            destination: 'prisma-relations.ts',
+            template: prismaRelations,
+        },
+    },
+});
+export const PRISMA_PRISMA_UTILS_TS_TEMPLATES = { utilsGroup };
+//# sourceMappingURL=ts-templates.js.map

package/dist/generators/prisma/prisma-utils/generated/ts-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.js","sourceRoot":"","sources":["../../../../../src/generators/prisma/prisma-utils/generated/ts-templates.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,54 @@
+export declare const prismaUtilsGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{}, {
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        prismaUtilsImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            applyDataPipeOutput: {};
+            applyDataPipeOutputToOperations: {};
+            applyDataPipeOutputWithoutOperation: {};
+            createOneToManyCreateData: {};
+            createOneToManyUpsertData: {};
+            createOneToOneCreateData: {};
+            createOneToOneUpsertData: {};
+            createPrismaDisconnectOrConnectData: {};
+            CreateServiceInput: {
+                isTypeOnly: true;
+            };
+            DataPipeOutput: {
+                isTypeOnly: true;
+            };
+            DeleteServiceInput: {
+                isTypeOnly: true;
+            };
+            mergePipeOperations: {};
+            UpdateServiceInput: {
+                isTypeOnly: true;
+            };
+            UpsertPayload: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }, any, any>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        serviceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createServiceContext: {};
+            createTestServiceContext: {};
+            ServiceContext: {
+                isTypeOnly: true;
+            };
+        }>>;
+        tsUtilsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            capitalizeString: {};
+            NormalizeTypes: {
+                isTypeOnly: true;
+            };
+            notEmpty: {};
+            restrictObjectNulls: {};
+        }>>;
+        prismaImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            prisma: {};
+        }>>;
+    }, any>;
+}>;
+export { prismaUtilsImportsProvider } from './generated/ts-import-maps.js';
+export type { PrismaUtilsImportsProvider } from './generated/ts-import-maps.js';
+//# sourceMappingURL=prisma-utils.generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-utils.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-utils/prisma-utils.generator.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C/B,CAAC;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,YAAY,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/generators/prisma/prisma-utils/prisma-utils.generator.js

@@ -0,0 +1,53 @@
+import { projectScope, tsUtilsImportsProvider, typescriptFileProvider, } from '@baseplate-dev/core-generators';
+import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { serviceContextImportsProvider } from '#src/generators/core/service-context/service-context.generator.js';
+import { prismaImportsProvider } from '../prisma/prisma.generator.js';
+import { createPrismaUtilsImports, prismaUtilsImportsProvider, } from './generated/ts-import-maps.js';
+import { PRISMA_PRISMA_UTILS_TS_TEMPLATES } from './generated/ts-templates.js';
+const descriptorSchema = z.object({});
+export const prismaUtilsGenerator = createGenerator({
+    name: 'prisma/prisma-utils',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        imports: createGeneratorTask({
+            exports: {
+                prismaUtilsImports: prismaUtilsImportsProvider.export(projectScope),
+            },
+            run() {
+                return {
+                    providers: {
+                        prismaUtilsImports: createPrismaUtilsImports('@/src/utils'),
+                    },
+                };
+            },
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                typescriptFile: typescriptFileProvider,
+                serviceContextImports: serviceContextImportsProvider,
+                tsUtilsImports: tsUtilsImportsProvider,
+                prismaImports: prismaImportsProvider,
+            },
+            run({ typescriptFile, serviceContextImports, tsUtilsImports, prismaImports, }) {
+                return {
+                    build: (builder) => {
+                        typescriptFile.addLazyTemplateGroup({
+                            group: PRISMA_PRISMA_UTILS_TS_TEMPLATES.utilsGroup,
+                            baseDirectory: '@/src/utils',
+                            generatorInfo: builder.generatorInfo,
+                            importMapProviders: {
+                                serviceContextImports,
+                                tsUtilsImports,
+                                prismaImports,
+                            },
+                        });
+                    },
+                };
+            },
+        }),
+    }),
+});
+export { prismaUtilsImportsProvider } from './generated/ts-import-maps.js';
+//# sourceMappingURL=prisma-utils.generator.js.map

package/dist/generators/prisma/prisma-utils/prisma-utils.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-utils.generator.js","sourceRoot":"","sources":["../../../../src/generators/prisma/prisma-utils/prisma-utils.generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,6BAA6B,EAAE,MAAM,mEAAmE,CAAC;AAElH,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EACL,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,gCAAgC,EAAE,MAAM,6BAA6B,CAAC;AAE/E,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEtC,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC;IAClD,IAAI,EAAE,qBAAqB;IAC3B,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IACjC,gBAAgB;IAChB,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;QACjB,OAAO,EAAE,mBAAmB,CAAC;YAC3B,OAAO,EAAE;gBACP,kBAAkB,EAAE,0BAA0B,CAAC,MAAM,CAAC,YAAY,CAAC;aACpE;YACD,GAAG;gBACD,OAAO;oBACL,SAAS,EAAE;wBACT,kBAAkB,EAAE,wBAAwB,CAAC,aAAa,CAAC;qBAC5D;iBACF,CAAC;YACJ,CAAC;SACF,CAAC;QACF,IAAI,EAAE,mBAAmB,CAAC;YACxB,YAAY,EAAE;gBACZ,cAAc,EAAE,sBAAsB;gBACtC,qBAAqB,EAAE,6BAA6B;gBACpD,cAAc,EAAE,sBAAsB;gBACtC,aAAa,EAAE,qBAAqB;aACrC;YACD,GAAG,CAAC,EACF,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,aAAa,GACd;gBACC,OAAO;oBACL,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE;wBACjB,cAAc,CAAC,oBAAoB,CAAC;4BAClC,KAAK,EAAE,gCAAgC,CAAC,UAAU;4BAClD,aAAa,EAAE,aAAa;4BAC5B,aAAa,EAAE,OAAO,CAAC,aAAa;4BACpC,kBAAkB,EAAE;gCAClB,qBAAqB;gCACrB,cAAc;gCACd,aAAa;6BACd;yBACF,CAAC,CAAC;oBACL,CAAC;iBACF,CAAC;YACJ,CAAC;SACF,CAAC;KACH,CAAC;CACH,CAAC,CAAC;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/generators/prisma/prisma-utils/templates/crud-service-types.ts

@@ -0,0 +1,35 @@
+// @ts-nocheck
+
+import type { ServiceContext } from '%serviceContextImports';
+
+export interface CreateServiceInput<
+  CreateData,
+  Query,
+  Context extends ServiceContext = ServiceContext,
+> {
+  data: CreateData;
+  context: Context;
+  query?: Query;
+}
+
+export interface UpdateServiceInput<
+  PrimaryKey,
+  UpdateData,
+  Query,
+  Context extends ServiceContext = ServiceContext,
+> {
+  id: PrimaryKey;
+  data: UpdateData;
+  context: Context;
+  query?: Query;
+}
+
+export interface DeleteServiceInput<
+  PrimaryKey,
+  Query,
+  Context extends ServiceContext = ServiceContext,
+> {
+  id: PrimaryKey;
+  context: Context;
+  query?: Query;
+}

package/dist/generators/prisma/prisma-utils/templates/data-pipes.ts

@@ -0,0 +1,86 @@
+// @ts-nocheck
+
+import type { Prisma } from '@prisma/client';
+
+import { prisma } from '%prismaImports';
+import { notEmpty } from '%tsUtilsImports';
+
+interface DataPipeOperations {
+  beforePrismaPromises?: Prisma.PrismaPromise<unknown>[];
+  afterPrismaPromises?: Prisma.PrismaPromise<unknown>[];
+}
+
+export interface DataPipeOutput<Output = unknown> {
+  data: Output;
+  operations?: DataPipeOperations;
+}
+
+export function mergePipeOperations(
+  outputs: (DataPipeOutput | DataPipeOperations | undefined | null)[],
+): DataPipeOperations {
+  const operations = outputs
+    .map((o) => (o && 'data' in o ? o.operations : o))
+    .filter(notEmpty);
+
+  return {
+    beforePrismaPromises: operations.flatMap(
+      (op) => op.beforePrismaPromises ?? [],
+    ),
+    afterPrismaPromises: operations.flatMap(
+      (op) => op.afterPrismaPromises ?? [],
+    ),
+  };
+}
+
+// Taken from Prisma generated code
+type UnwrapPromise<P> = P extends Promise<infer R> ? R : P;
+type UnwrapTuple<Tuple extends readonly unknown[]> = {
+  [K in keyof Tuple]: K extends `${number}`
+    ? Tuple[K] extends Prisma.PrismaPromise<infer X>
+      ? X
+      : UnwrapPromise<Tuple[K]>
+    : UnwrapPromise<Tuple[K]>;
+};
+
+export async function applyDataPipeOutputToOperations<
+  Promises extends Prisma.PrismaPromise<unknown>[],
+>(
+  outputs: (DataPipeOutput | DataPipeOperations | undefined | null)[],
+  operations: [...Promises],
+): Promise<UnwrapTuple<Promises>> {
+  const { beforePrismaPromises = [], afterPrismaPromises = [] } =
+    mergePipeOperations(outputs);
+  const results = await prisma.$transaction([
+    ...beforePrismaPromises,
+    ...operations,
+    ...afterPrismaPromises,
+  ]);
+
+  return results.slice(
+    beforePrismaPromises.length,
+    beforePrismaPromises.length + operations.length,
+  ) as UnwrapTuple<Promises>;
+}
+
+export async function applyDataPipeOutput<DataType>(
+  outputs: (DataPipeOutput | DataPipeOperations | undefined | null)[],
+  operation: Prisma.PrismaPromise<DataType>,
+): Promise<DataType> {
+  const { beforePrismaPromises = [], afterPrismaPromises = [] } =
+    mergePipeOperations(outputs);
+  const results = await prisma.$transaction([
+    ...beforePrismaPromises,
+    operation,
+    ...afterPrismaPromises,
+  ]);
+
+  return results[beforePrismaPromises.length] as DataType;
+}
+
+export async function applyDataPipeOutputWithoutOperation(
+  outputs: (DataPipeOutput | DataPipeOperations | undefined | null)[],
+): Promise<void> {
+  const { beforePrismaPromises = [], afterPrismaPromises = [] } =
+    mergePipeOperations(outputs);
+  await prisma.$transaction([...beforePrismaPromises, ...afterPrismaPromises]);
+}