@wokcito/prisma-generator-pothos-codegen 1.0.0

package/src/crudGenerator/templates/mutation.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutations = void 0;
+const resolver_1 = require("./resolver");
+const mutationNames = ['createMany', 'createOne', 'deleteMany', 'deleteOne', 'updateMany', 'updateOne', 'upsertOne'];
+const makeMutation = (operation, type, nullable, args, resolve, isPrisma = true) => (0, resolver_1.makeResolver)('Mutation', isPrisma ? '' : "\nimport { BatchPayload } from '../../objects';", operation, type, nullable, args, resolve, isPrisma);
+const createManyArgs = '{ data: t.field({ type: [Inputs.#{modelName}CreateInput], required: true }) }';
+const createManyResolver = `async (_query, _root, args, _context, _info) =>
+      await #{prisma}.$transaction(args.data.map((data) => #{prisma}.#{modelNameLower}.create({ data })))`;
+const createMany = makeMutation('createMany', "['#{modelName}']", 'false', createManyArgs, createManyResolver);
+const createOneArgs = '{ data: t.field({ type: Inputs.#{modelName}CreateInput, required: true }) }';
+const createOneResolver = `async (query, _root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.create({ data: args.data, ...query })`;
+const createOne = makeMutation('createOne', "'#{modelName}'", 'false', createOneArgs, createOneResolver);
+const deleteManyArgs = '{ where: t.field({ type: Inputs.#{modelName}WhereInput, required: true }) }';
+const deleteManyResolver = `async (_root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.deleteMany({ where: args.where })`;
+const deleteMany = makeMutation('deleteMany', 'BatchPayload', 'true', deleteManyArgs, deleteManyResolver, false);
+const delteOneArgs = '{ where: t.field({ type: Inputs.#{modelName}WhereUniqueInput, required: true }) }';
+const deleteOneResolver = `async (query, _root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.delete({ where: args.where, ...query })`;
+const deleteOne = makeMutation('deleteOne', "'#{modelName}'", 'true', delteOneArgs, deleteOneResolver);
+const updateManyArgs = `{
+      where: t.field({ type: Inputs.#{modelName}WhereInput, required: false }),
+      data: t.field({ type: Inputs.#{modelName}UpdateManyMutationInput, required: true }),
+    }`;
+const updateManyResolver = `async (_root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.updateMany({ where: args.where || undefined, data: args.data })`;
+const updateMany = makeMutation('updateMany', 'BatchPayload', 'false', updateManyArgs, updateManyResolver, false);
+const updateOneArgs = `{
+      where: t.field({ type: Inputs.#{modelName}WhereUniqueInput, required: true }),
+      data: t.field({ type: Inputs.#{modelName}UpdateInput, required: true }),
+    }`;
+const updateOneResolver = `async (query, _root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.update({ where: args.where, data: args.data, ...query })`;
+const updateOne = makeMutation('updateOne', "'#{modelName}'", 'true', updateOneArgs, updateOneResolver);
+const upsertOneArgs = `{
+      where: t.field({ type: Inputs.#{modelName}WhereUniqueInput, required: true }),
+      create: t.field({ type: Inputs.#{modelName}CreateInput, required: true }),
+      update: t.field({ type: Inputs.#{modelName}UpdateInput, required: true }),
+    }`;
+const upsertOneResolver = `async (query, _root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.upsert({
+        where: args.where,
+        create: args.create,
+        update: args.update,
+        ...query,
+      })`;
+const upsertOne = makeMutation('upsertOne', "'#{modelName}'", 'false', upsertOneArgs, upsertOneResolver);
+exports.mutations = {
+    createMany,
+    createOne,
+    deleteMany,
+    deleteOne,
+    updateMany,
+    updateOne,
+    upsertOne,
+};
+//# sourceMappingURL=mutation.js.map

package/src/crudGenerator/templates/mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.js","sourceRoot":"","sources":["../../../../src/crudGenerator/templates/mutation.ts"],"names":[],"mappings":";;;AAAA,yCAAyC;AAEzC,MAAM,aAAa,GAAG,CAAC,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,CAAC,CAAA;AAGpH,MAAM,YAAY,GAAG,CACnB,SAA2B,EAC3B,IAAY,EACZ,QAA0B,EAC1B,IAAY,EACZ,OAAe,EACf,QAAQ,GAAG,IAAI,EACf,EAAE,CACF,IAAA,uBAAY,EACV,UAAU,EACV,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iDAAiD,EACjE,SAAS,EACT,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,QAAQ,CACT,CAAA;AAEH,MAAM,cAAc,GAAG,+EAA+E,CAAA;AAEtG,MAAM,kBAAkB,GAAG;0GAC+E,CAAA;AAE1G,MAAM,UAAU,GAAG,YAAY,CAAC,YAAY,EAAE,kBAAkB,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,CAAC,CAAA;AAE9G,MAAM,aAAa,GAAG,6EAA6E,CAAA;AAEnG,MAAM,iBAAiB,GAAG;8EACoD,CAAA;AAE9E,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAA;AAExG,MAAM,cAAc,GAAG,6EAA6E,CAAA;AAEpG,MAAM,kBAAkB,GAAG;0EAC+C,CAAA;AAE1E,MAAM,UAAU,GAAG,YAAY,CAAC,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,kBAAkB,EAAE,KAAK,CAAC,CAAA;AAEhH,MAAM,YAAY,GAAG,mFAAmF,CAAA;AAExG,MAAM,iBAAiB,GAAG;gFACsD,CAAA;AAEhF,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,EAAE,iBAAiB,CAAC,CAAA;AAEtG,MAAM,cAAc,GAAG;;;MAGjB,CAAA;AAEN,MAAM,kBAAkB,GAAG;wGAC6E,CAAA;AAExG,MAAM,UAAU,GAAG,YAAY,CAAC,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,KAAK,CAAC,CAAA;AAEjH,MAAM,aAAa,GAAG;;;MAGhB,CAAA;AAEN,MAAM,iBAAiB,GAAG;iGACuE,CAAA;AAEjG,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAA;AAEvG,MAAM,aAAa,GAAG;;;;MAIhB,CAAA;AAEN,MAAM,iBAAiB,GAAG;;;;;;SAMjB,CAAA;AAET,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAA;AAE3F,QAAA,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,UAAU;IACV,SAAS;IACT,UAAU;IACV,SAAS;IACT,SAAS;CACV,CAAA"}

package/src/crudGenerator/templates/object.d.ts

@@ -0,0 +1,4 @@
+export declare const objectTemplate = "#{inputsImporter}#{builderCalculatedImport}\nimport {\n  definePrismaObject,\n  defineFieldObject,\n  defineRelationFunction,\n  defineRelationObject,\n} from '../utils';\n\nexport const #{modelName}#{optionalUnderscore}Object = definePrismaObject('#{modelName}', {\n  description: #{description},\n  findUnique: #{findUnique},\n  fields: (t) => ({\n    #{fields}\n  }),\n});\n\n#{exportFields}\n";
+export declare const fieldObjectTemplate = "export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineFieldObject('#{modelName}', {\n  type: #{conditionalType},\n  description: #{description},\n  nullable: #{nullable},\n  resolve: (parent) => #{conditionalResolve},\n});";
+export declare const listRelationObjectTemplate = "export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldArgs = builder.args((t) => ({\n  where: t.field({ type: Inputs.#{type}WhereInput, required: false }),\n  orderBy: t.field({ type: [Inputs.#{type}OrderByWithRelationInput], required: false }),\n  cursor: t.field({ type: Inputs.#{type}WhereUniqueInput, required: false }),\n  take: t.field({ type: 'Int', required: false }),\n  skip: t.field({ type: 'Int', required: false }),\n  distinct: t.field({ type: [Inputs.#{typeUpper}ScalarFieldEnum], required: false }),\n}))\n\nexport const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineRelationFunction('#{modelName}', (t) =>\n  defineRelationObject('#{modelName}', '#{name}', {\n    description: #{description},\n    nullable: #{nullable},\n    args: #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldArgs,\n    query: (args) => ({\n      where: args.where || undefined,\n      cursor: args.cursor || undefined,\n      take: args.take || undefined,\n      distinct: args.distinct || undefined,\n      skip: args.skip || undefined,\n      orderBy: args.orderBy || undefined,\n    }),\n  }),\n);";
+export declare const relationObjectTemplate = "export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineRelationObject('#{modelName}', '#{name}', {\n  description: #{description},\n  nullable: #{nullable},\n  args: undefined,\n  query: undefined,\n});";

package/src/crudGenerator/templates/object.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationObjectTemplate = exports.listRelationObjectTemplate = exports.fieldObjectTemplate = exports.objectTemplate = void 0;
+// TODO only import what is necessary
+exports.objectTemplate = `#{inputsImporter}#{builderCalculatedImport}
+import {
+  definePrismaObject,
+  defineFieldObject,
+  defineRelationFunction,
+  defineRelationObject,
+} from '../utils';
+
+export const #{modelName}#{optionalUnderscore}Object = definePrismaObject('#{modelName}', {
+  description: #{description},
+  findUnique: #{findUnique},
+  fields: (t) => ({
+    #{fields}
+  }),
+});
+
+#{exportFields}
+`;
+exports.fieldObjectTemplate = `export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineFieldObject('#{modelName}', {
+  type: #{conditionalType},
+  description: #{description},
+  nullable: #{nullable},
+  resolve: (parent) => #{conditionalResolve},
+});`;
+exports.listRelationObjectTemplate = `export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldArgs = builder.args((t) => ({
+  where: t.field({ type: Inputs.#{type}WhereInput, required: false }),
+  orderBy: t.field({ type: [Inputs.#{type}OrderByWithRelationInput], required: false }),
+  cursor: t.field({ type: Inputs.#{type}WhereUniqueInput, required: false }),
+  take: t.field({ type: 'Int', required: false }),
+  skip: t.field({ type: 'Int', required: false }),
+  distinct: t.field({ type: [Inputs.#{typeUpper}ScalarFieldEnum], required: false }),
+}))
+
+export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineRelationFunction('#{modelName}', (t) =>
+  defineRelationObject('#{modelName}', '#{name}', {
+    description: #{description},
+    nullable: #{nullable},
+    args: #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldArgs,
+    query: (args) => ({
+      where: args.where || undefined,
+      cursor: args.cursor || undefined,
+      take: args.take || undefined,
+      distinct: args.distinct || undefined,
+      skip: args.skip || undefined,
+      orderBy: args.orderBy || undefined,
+    }),
+  }),
+);`;
+exports.relationObjectTemplate = `export const #{modelName}#{optionalUnderscore}#{nameUpper}#{optionalUnderscore}FieldObject = defineRelationObject('#{modelName}', '#{name}', {
+  description: #{description},
+  nullable: #{nullable},
+  args: undefined,
+  query: undefined,
+});`;
+//# sourceMappingURL=object.js.map

package/src/crudGenerator/templates/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../../../src/crudGenerator/templates/object.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AACxB,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;CAiB7B,CAAA;AAEY,QAAA,mBAAmB,GAAG;;;;;IAK/B,CAAA;AAES,QAAA,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;GAuBvC,CAAA;AAEU,QAAA,sBAAsB,GAAG;;;;;IAKlC,CAAA"}

package/src/crudGenerator/templates/query.d.ts

@@ -0,0 +1,6 @@
+export declare const queries: {
+    findFirst: string;
+    findMany: string;
+    count: string;
+    findUnique: string;
+};

package/src/crudGenerator/templates/query.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queries = void 0;
+const template_1 = require("../../utils/template");
+const resolver_1 = require("./resolver");
+const queryNames = ['findFirst', 'findMany', 'count', 'findUnique'];
+const makeQuery = (operation, type, nullable, isPrisma = true, args, resolve) => (0, resolver_1.makeResolver)('Query', '', operation, type, nullable, args !== null && args !== void 0 ? args : (0, template_1.useTemplate)(queryListArgsTemplate, {}, ['modelName', 'modelNameUpper']), resolve !== null && resolve !== void 0 ? resolve : (0, template_1.useTemplate)(queryListResolveTemplate, {
+    distinct: operation === 'count' ? '' : '\n        distinct: args.distinct || undefined,',
+    operation,
+    query: isPrisma ? '\n        ...query,' : '',
+    argsQuery: isPrisma ? 'query, ' : '',
+}, ['prisma', 'modelNameLower']), isPrisma);
+const queryListArgsTemplate = `{
+  where: t.field({ type: Inputs.#{modelName}WhereInput, required: false }),
+  orderBy: t.field({ type: [Inputs.#{modelName}OrderByWithRelationInput], required: false }),
+  cursor: t.field({ type: Inputs.#{modelName}WhereUniqueInput, required: false }),
+  take: t.field({ type: 'Int', required: false }),
+  skip: t.field({ type: 'Int', required: false }),
+  distinct: t.field({ type: [Inputs.#{modelNameUpper}ScalarFieldEnum], required: false }),
+}`;
+const queryListResolveTemplate = `async (#{argsQuery}_root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.#{operation}({
+        where: args.where || undefined,
+        cursor: args.cursor || undefined,
+        take: args.take || undefined,#{distinct}
+        skip: args.skip || undefined,
+        orderBy: args.orderBy || undefined,#{query}
+      })`;
+const querySingleArgsTemplate = `{ where: t.field({ type: Inputs.#{modelName}WhereUniqueInput, required: true }) }`;
+const querySingleResolveTemplate = `async (query, _root, args, _context, _info) =>
+      await #{prisma}.#{modelNameLower}.findUnique({ where: args.where, ...query })`;
+const findFirst = makeQuery('findFirst', "'#{modelName}'", 'true');
+const findMany = makeQuery('findMany', "['#{modelName}']", 'false');
+const count = makeQuery('count', "'Int'", 'false', false);
+const findUnique = makeQuery('findUnique', "'#{modelName}'", 'true', true, (0, template_1.useTemplate)(querySingleArgsTemplate, {}, ['modelName']), (0, template_1.useTemplate)(querySingleResolveTemplate, {}, ['prisma', 'modelNameLower']));
+exports.queries = { findFirst, findMany, count, findUnique };
+//# sourceMappingURL=query.js.map

package/src/crudGenerator/templates/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../../src/crudGenerator/templates/query.ts"],"names":[],"mappings":";;;AAAA,mDAAkD;AAClD,yCAAyC;AAEzC,MAAM,UAAU,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,CAAU,CAAA;AAG5E,MAAM,SAAS,GAAG,CAChB,SAA2B,EAC3B,IAAY,EACZ,QAA0B,EAC1B,QAAQ,GAAG,IAAI,EACf,IAAa,EACb,OAAgB,EAChB,EAAE,CACF,IAAA,uBAAY,EACV,OAAO,EACP,EAAE,EACF,SAAS,EACT,IAAI,EACJ,QAAQ,EACR,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,IAAA,sBAAW,EAAC,qBAAqB,EAAE,EAAE,EAAE,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,EAC/E,OAAO,aAAP,OAAO,cAAP,OAAO,GACL,IAAA,sBAAW,EACT,wBAAwB,EACxB;IACE,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iDAAiD;IACxF,SAAS;IACT,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE;IAC5C,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;CACrC,EACD,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAC7B,EACH,QAAQ,CACT,CAAA;AAEH,MAAM,qBAAqB,GAAG;;;;;;;EAO5B,CAAA;AAEF,MAAM,wBAAwB,GAAG;;;;;;;SAOxB,CAAA;AAET,MAAM,uBAAuB,GAAG,mFAAmF,CAAA;AAEnH,MAAM,0BAA0B,GAAG;oFACiD,CAAA;AAEpF,MAAM,SAAS,GAAG,SAAS,CAAC,WAAW,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAA;AAElE,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAA;AAEnE,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAA;AAEzD,MAAM,UAAU,GAAG,SAAS,CAC1B,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,IAAI,EACJ,IAAA,sBAAW,EAAC,uBAAuB,EAAE,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,EACvD,IAAA,sBAAW,EAAC,0BAA0B,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAC1E,CAAA;AAEY,QAAA,OAAO,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,CAAA"}

package/src/crudGenerator/templates/resolver.d.ts

@@ -0,0 +1,2 @@
+export declare const makeResolver: (root: "Query" | "Mutation", imports: string, operation: string, type: string, nullable: "true" | "false", args: string, resolve: string, isPrisma?: boolean) => string;
+export declare const resolverTemplate = "#{inputsImporter}#{imports}#{resolverImports}#{builderCalculatedImport}\nimport { define#{root}, define#{root}Function, define#{root}#{object} } from '../../utils';\n\nexport const #{operation}#{modelName}#{root}Args = builder.args((t) => (#{args}))\n\nexport const #{operation}#{modelName}#{root}Object = define#{root}Function((t) =>\n  define#{root}#{object}({\n    type: #{type},\n    nullable: #{nullable},\n    args: #{operation}#{modelName}#{root}Args,\n    resolve: #{resolve},\n  }),\n);\n\nexport const #{operation}#{modelName}#{root} = define#{root}((t) => ({\n  #{operation}#{modelName}: t.#{field}(#{operation}#{modelName}#{root}Object(t)),\n}));\n";

package/src/crudGenerator/templates/resolver.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolverTemplate = exports.makeResolver = void 0;
+const template_1 = require("../../utils/template");
+const makeResolver = (root, imports, operation, type, nullable, args, resolve, isPrisma = true) => (0, template_1.useTemplate)(exports.resolverTemplate, {
+    root,
+    object: isPrisma ? 'PrismaObject' : 'Object',
+    imports,
+    operation,
+    type,
+    nullable,
+    args,
+    resolve,
+    field: isPrisma ? 'prismaField' : 'field',
+}, ['modelName', 'inputsImporter', 'resolverImports', 'builderCalculatedImport']);
+exports.makeResolver = makeResolver;
+exports.resolverTemplate = `#{inputsImporter}#{imports}#{resolverImports}#{builderCalculatedImport}
+import { define#{root}, define#{root}Function, define#{root}#{object} } from '../../utils';
+
+export const #{operation}#{modelName}#{root}Args = builder.args((t) => (#{args}))
+
+export const #{operation}#{modelName}#{root}Object = define#{root}Function((t) =>
+  define#{root}#{object}({
+    type: #{type},
+    nullable: #{nullable},
+    args: #{operation}#{modelName}#{root}Args,
+    resolve: #{resolve},
+  }),
+);
+
+export const #{operation}#{modelName}#{root} = define#{root}((t) => ({
+  #{operation}#{modelName}: t.#{field}(#{operation}#{modelName}#{root}Object(t)),
+}));
+`;
+//# sourceMappingURL=resolver.js.map

package/src/crudGenerator/templates/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../../../src/crudGenerator/templates/resolver.ts"],"names":[],"mappings":";;;AAAA,mDAAkD;AAE3C,MAAM,YAAY,GAAG,CAC1B,IAA0B,EAC1B,OAAe,EACf,SAAiB,EACjB,IAAY,EACZ,QAA0B,EAC1B,IAAY,EACZ,OAAe,EACf,QAAQ,GAAG,IAAI,EACf,EAAE,CACF,IAAA,sBAAW,EACT,wBAAgB,EAChB;IACE,IAAI;IACJ,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,QAAQ;IAC5C,OAAO;IACP,SAAS;IACT,IAAI;IACJ,QAAQ;IACR,IAAI;IACJ,OAAO;IACP,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO;CAC1C,EACD,CAAC,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,yBAAyB,CAAC,CAC9E,CAAA;AAxBU,QAAA,YAAY,gBAwBtB;AAEU,QAAA,gBAAgB,GAAG;;;;;;;;;;;;;;;;;CAiB/B,CAAA"}

package/src/crudGenerator/templates/root.d.ts

@@ -0,0 +1,20 @@
+export declare const objectsTemplate = "#{prismaImporter}#{crudExportRoot}#{builderCalculatedImport}\n\nexport const BatchPayload = builder.objectType(builder.objectRef<Prisma.BatchPayload>('BatchPayload'), {\n  description: 'Batch payloads from prisma.',\n  fields: (t) => ({\n    count: t.exposeInt('count', { description: 'Prisma Batch Payload', nullable: false }),\n  }),\n});\n\nexport const modelNames = [\n  #{modelNames}\n] as const;\n\nexport type Model = typeof modelNames[number];\n";
+export declare const utilsTemplate = "import {\n  FieldOptionsFromKind,\n  InputFieldMap,\n  InterfaceParam,\n  MutationFieldBuilder,\n  MutationFieldsShape,\n  ObjectRef,\n  QueryFieldBuilder,\n  QueryFieldsShape,\n  TypeParam,\n} from '@pothos/core';\nimport {\n  PrismaFieldOptions,\n  PrismaObjectTypeOptions,\n  RelatedFieldOptions,\n} from '@pothos/plugin-prisma';#{builderCalculatedImport}\n\ntype Types = typeof builder extends PothosSchemaTypes.SchemaBuilder<infer T> ? T : unknown;\n\nexport const defineQuery = <Q extends QueryFieldsShape<Types>>(q: Q) => q;\n\nexport const defineQueryFunction = <Obj>(\n  func: (t: QueryFieldBuilder<Types, Types['Root']>) => Obj,\n) => func;\n\nexport const defineQueryObject = <\n  Type extends TypeParam<Types>,\n  Nullable extends boolean,\n  Args extends InputFieldMap,\n>(\n  obj: FieldOptionsFromKind<Types, Types['Root'], Type, Nullable, Args, 'Query', Types, unknown>,\n) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };\n\nexport const defineQueryPrismaObject = <\n  Type extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],\n  Model extends Types['PrismaTypes'][Type extends [unknown] ? Type[0] : Type],\n  Args extends InputFieldMap,\n  Nullable extends boolean,\n>(\n  def: PrismaFieldOptions<\n    Types,\n    Types['Root'],\n    Type,\n    Model,\n    Type extends [unknown] ? [ObjectRef<Types, Model['Shape']>] : ObjectRef<Types, Model['Shape']>,\n    Args,\n    Nullable,\n    unknown,\n    unknown,\n    'Query'\n  >,\n) => def as { type: Type; nullable: Nullable; args: Args; resolve: typeof def['resolve'] };\n\nexport const defineMutation = <M extends MutationFieldsShape<Types>>(m: M) => m;\n\nexport const defineMutationFunction = <Obj>(\n  func: (t: MutationFieldBuilder<Types, Types['Root']>) => Obj,\n) => func;\n\nexport const defineMutationObject = <\n  Type extends TypeParam<Types>,\n  Nullable extends boolean,\n  Args extends InputFieldMap,\n>(\n  obj: FieldOptionsFromKind<Types, Types['Root'], Type, Nullable, Args, 'Mutation', Types, unknown>,\n) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };\n\nexport const defineMutationPrismaObject = <\n  Type extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],\n  Model extends Types['PrismaTypes'][Type extends [unknown] ? Type[0] : Type],\n  Args extends InputFieldMap,\n  Nullable extends boolean,\n>(\n  obj: PrismaFieldOptions<\n    Types,\n    Types['Root'],\n    Type,\n    Model,\n    Type extends [unknown] ? [ObjectRef<Types, Model['Shape']>] : ObjectRef<Types, Model['Shape']>,\n    Args,\n    Nullable,\n    unknown,\n    unknown,\n    'Mutation'\n  >,\n) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };\n\nexport const defineFieldObject = <\n  Name extends keyof Types['PrismaTypes'],\n  Type extends TypeParam<Types>,\n  Nullable extends boolean,\n  Args extends InputFieldMap,\n>(\n  _: Name,\n  obj: FieldOptionsFromKind<\n    Types,\n    Types['PrismaTypes'][Name]['Shape'],\n    Type,\n    Nullable,\n    Args,\n    'Object',\n    unknown,\n    unknown\n  >,\n) =>\n  obj as { type: Type; nullable: Nullable; description?: string; resolve: typeof obj['resolve'] };\n\nexport const defineRelationObject = <\n  ModelName extends keyof Types['PrismaTypes'],\n  RelationName extends keyof Types['PrismaTypes'][ModelName]['Relations'],\n  Nullable extends boolean,\n  Args extends InputFieldMap,\n>(\n  _: ModelName,\n  __: RelationName,\n  obj: RelatedFieldOptions<\n    Types,\n    Types['PrismaTypes'][ModelName],\n    RelationName,\n    Nullable,\n    Args,\n    unknown,\n    Types['PrismaTypes'][ModelName]['Shape']\n  >,\n) =>\n  obj as {\n    description: string | undefined;\n    nullable: Nullable;\n    args: Args;\n    query: typeof obj['query'];\n  };\n\nexport const defineRelationFunction = <ModelName extends keyof Types['PrismaTypes'], O>(\n  _: ModelName,\n  func: (\n    t: PothosSchemaTypes.PrismaObjectFieldBuilder<\n      Types,\n      Types['PrismaTypes'][ModelName],\n      Types['PrismaTypes'][ModelName]['Shape']\n    >,\n  ) => O,\n) => func;\n\nexport const definePrismaObject = <\n  Name extends keyof Types['PrismaTypes'],\n  Obj extends PrismaObjectTypeOptions<\n    Types,\n    Types['PrismaTypes'][Name],\n    InterfaceParam<Types>[],\n    unknown,\n    unknown,\n    Types['PrismaTypes'][Name]['Shape']\n  >,\n>(\n  _: Name,\n  obj: Obj,\n) => obj;\n";
+/**
+  User: {
+    Object: User.UserObject,
+    queries: {},
+    mutations: {},
+  },
+  Post: {
+    Object: Post.PostObject,
+    queries: {
+      findFirst: Post.findFirstPostQuery,
+      count: Post.countPostQuery,
+    },
+    mutations: {
+      createOne: Post.createOnePostMutation,
+    },
+  },
+ */
+export declare const autoCrudTemplate = "#{imports}#{builderCalculatedImport}\nimport * as Objects from './objects';\n\ntype Model = Objects.Model;\n\nexport const Cruds: Record<\n  Objects.Model,\n  {\n    Object: any;\n    queries: Record<string, Function>;\n    mutations: Record<string, Function>;\n  }\n> = {\n#{modelsGenerated}\n};\n\nconst crudEntries = Object.entries(Cruds);\n\ntype ResolverType = \"Query\" | \"Mutation\";\nfunction generateResolversByType(type: ResolverType, opts?: CrudOptions) {\n  return crudEntries\n    .filter(([modelName]) => includeModel(modelName, opts))\n    .map(([modelName, config]) => {\n      const resolverEntries = Object.entries(config[type === \"Query\" ? \"queries\" : \"mutations\"]);\n\n      return resolverEntries.map(([operationName, resolverObjectDefiner]) => {\n        const resolverName = operationName + modelName;\n        const isntPrismaFieldList = [\"count\", \"deleteMany\", \"updateMany\"];\n        const isPrismaField = !isntPrismaFieldList.includes(operationName);\n\n        const getFields = (t: any) => {\n          const field = resolverObjectDefiner(t);\n          const handledField = opts?.handleResolver\n            ? opts.handleResolver({\n                field,\n                modelName: modelName as Model,\n                operationName,\n                resolverName,\n                t,\n                isPrismaField,\n                type,\n              })\n            : field;\n\n          return {\n            [resolverName]: isPrismaField\n              ? t.prismaField(handledField)\n              : t.field(handledField),\n          }\n        }\n\n        return type === \"Query\"\n          ? builder.queryFields((t) => getFields(t))\n          : builder.mutationFields((t) => getFields(t));\n      });\n    });\n}\n\nexport function generateAllObjects(opts?: CrudOptions) {\n  return crudEntries\n    .filter(([md]) => includeModel(md, opts))\n    .map(([modelName, { Object }]) => {\n      return builder.prismaObject(modelName as Model, Object); // Objects is all imports\n    });\n}\n\nexport function generateAllQueries(opts?: CrudOptions) {\n  generateResolversByType(\"Query\", opts);\n}\n\nexport function generateAllMutations(opts?: CrudOptions) {\n  generateResolversByType(\"Mutation\", opts);\n}\n\nexport function generateAllResolvers(opts?: CrudOptions) {\n  generateResolversByType(\"Mutation\", opts);\n  generateResolversByType(\"Query\", opts);\n}\n\ntype CrudOptions = {\n  include?: Model[];\n  exclude?: Model[];\n  /**\n   * Caution: This is not type safe\n   * Wrap all queries/mutations to override args, run extra code in resolve function (ie: throw errors, logs), apply plugins, etc.\n   */\n  handleResolver?: (props: {\n    modelName: Model;\n    field: any;\n    operationName: string;\n    resolverName: string;\n    t: any;\n    isPrismaField: boolean;\n    type: ResolverType;\n  }) => any;\n};\n\nconst includeModel = (model: string, opts?: CrudOptions): boolean => {\n  if (!opts) return true;\n  if (opts.include) return opts.include.includes(model as Model);\n  if (opts.exclude) return !opts.exclude.includes(model as Model);\n  return true;\n};\n\nexport function generateAllCrud(opts?: CrudOptions) {\n  generateAllObjects(opts);\n  generateAllQueries(opts);\n  generateAllMutations(opts);\n}\n";

package/src/crudGenerator/templates/root.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoCrudTemplate = exports.utilsTemplate = exports.objectsTemplate = void 0;
+exports.objectsTemplate = `#{prismaImporter}#{crudExportRoot}#{builderCalculatedImport}
+
+export const BatchPayload = builder.objectType(builder.objectRef<Prisma.BatchPayload>('BatchPayload'), {
+  description: 'Batch payloads from prisma.',
+  fields: (t) => ({
+    count: t.exposeInt('count', { description: 'Prisma Batch Payload', nullable: false }),
+  }),
+});
+
+export const modelNames = [
+  #{modelNames}
+] as const;
+
+export type Model = typeof modelNames[number];
+`;
+exports.utilsTemplate = `import {
+  FieldOptionsFromKind,
+  InputFieldMap,
+  InterfaceParam,
+  MutationFieldBuilder,
+  MutationFieldsShape,
+  ObjectRef,
+  QueryFieldBuilder,
+  QueryFieldsShape,
+  TypeParam,
+} from '@pothos/core';
+import {
+  PrismaFieldOptions,
+  PrismaObjectTypeOptions,
+  RelatedFieldOptions,
+} from '@pothos/plugin-prisma';#{builderCalculatedImport}
+
+type Types = typeof builder extends PothosSchemaTypes.SchemaBuilder<infer T> ? T : unknown;
+
+export const defineQuery = <Q extends QueryFieldsShape<Types>>(q: Q) => q;
+
+export const defineQueryFunction = <Obj>(
+  func: (t: QueryFieldBuilder<Types, Types['Root']>) => Obj,
+) => func;
+
+export const defineQueryObject = <
+  Type extends TypeParam<Types>,
+  Nullable extends boolean,
+  Args extends InputFieldMap,
+>(
+  obj: FieldOptionsFromKind<Types, Types['Root'], Type, Nullable, Args, 'Query', Types, unknown>,
+) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };
+
+export const defineQueryPrismaObject = <
+  Type extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+  Model extends Types['PrismaTypes'][Type extends [unknown] ? Type[0] : Type],
+  Args extends InputFieldMap,
+  Nullable extends boolean,
+>(
+  def: PrismaFieldOptions<
+    Types,
+    Types['Root'],
+    Type,
+    Model,
+    Type extends [unknown] ? [ObjectRef<Types, Model['Shape']>] : ObjectRef<Types, Model['Shape']>,
+    Args,
+    Nullable,
+    unknown,
+    unknown,
+    'Query'
+  >,
+) => def as { type: Type; nullable: Nullable; args: Args; resolve: typeof def['resolve'] };
+
+export const defineMutation = <M extends MutationFieldsShape<Types>>(m: M) => m;
+
+export const defineMutationFunction = <Obj>(
+  func: (t: MutationFieldBuilder<Types, Types['Root']>) => Obj,
+) => func;
+
+export const defineMutationObject = <
+  Type extends TypeParam<Types>,
+  Nullable extends boolean,
+  Args extends InputFieldMap,
+>(
+  obj: FieldOptionsFromKind<Types, Types['Root'], Type, Nullable, Args, 'Mutation', Types, unknown>,
+) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };
+
+export const defineMutationPrismaObject = <
+  Type extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+  Model extends Types['PrismaTypes'][Type extends [unknown] ? Type[0] : Type],
+  Args extends InputFieldMap,
+  Nullable extends boolean,
+>(
+  obj: PrismaFieldOptions<
+    Types,
+    Types['Root'],
+    Type,
+    Model,
+    Type extends [unknown] ? [ObjectRef<Types, Model['Shape']>] : ObjectRef<Types, Model['Shape']>,
+    Args,
+    Nullable,
+    unknown,
+    unknown,
+    'Mutation'
+  >,
+) => obj as { type: Type; nullable: Nullable; args: Args; resolve: typeof obj['resolve'] };
+
+export const defineFieldObject = <
+  Name extends keyof Types['PrismaTypes'],
+  Type extends TypeParam<Types>,
+  Nullable extends boolean,
+  Args extends InputFieldMap,
+>(
+  _: Name,
+  obj: FieldOptionsFromKind<
+    Types,
+    Types['PrismaTypes'][Name]['Shape'],
+    Type,
+    Nullable,
+    Args,
+    'Object',
+    unknown,
+    unknown
+  >,
+) =>
+  obj as { type: Type; nullable: Nullable; description?: string; resolve: typeof obj['resolve'] };
+
+export const defineRelationObject = <
+  ModelName extends keyof Types['PrismaTypes'],
+  RelationName extends keyof Types['PrismaTypes'][ModelName]['Relations'],
+  Nullable extends boolean,
+  Args extends InputFieldMap,
+>(
+  _: ModelName,
+  __: RelationName,
+  obj: RelatedFieldOptions<
+    Types,
+    Types['PrismaTypes'][ModelName],
+    RelationName,
+    Nullable,
+    Args,
+    unknown,
+    Types['PrismaTypes'][ModelName]['Shape']
+  >,
+) =>
+  obj as {
+    description: string | undefined;
+    nullable: Nullable;
+    args: Args;
+    query: typeof obj['query'];
+  };
+
+export const defineRelationFunction = <ModelName extends keyof Types['PrismaTypes'], O>(
+  _: ModelName,
+  func: (
+    t: PothosSchemaTypes.PrismaObjectFieldBuilder<
+      Types,
+      Types['PrismaTypes'][ModelName],
+      Types['PrismaTypes'][ModelName]['Shape']
+    >,
+  ) => O,
+) => func;
+
+export const definePrismaObject = <
+  Name extends keyof Types['PrismaTypes'],
+  Obj extends PrismaObjectTypeOptions<
+    Types,
+    Types['PrismaTypes'][Name],
+    InterfaceParam<Types>[],
+    unknown,
+    unknown,
+    Types['PrismaTypes'][Name]['Shape']
+  >,
+>(
+  _: Name,
+  obj: Obj,
+) => obj;
+`;
+// TODO: Refactor getParams to link model with object base, and remove any
+/**
+  User: {
+    Object: User.UserObject,
+    queries: {},
+    mutations: {},
+  },
+  Post: {
+    Object: Post.PostObject,
+    queries: {
+      findFirst: Post.findFirstPostQuery,
+      count: Post.countPostQuery,
+    },
+    mutations: {
+      createOne: Post.createOnePostMutation,
+    },
+  },
+ */
+exports.autoCrudTemplate = `#{imports}#{builderCalculatedImport}
+import * as Objects from './objects';
+
+type Model = Objects.Model;
+
+export const Cruds: Record<
+  Objects.Model,
+  {
+    Object: any;
+    queries: Record<string, Function>;
+    mutations: Record<string, Function>;
+  }
+> = {
+#{modelsGenerated}
+};
+
+const crudEntries = Object.entries(Cruds);
+
+type ResolverType = "Query" | "Mutation";
+function generateResolversByType(type: ResolverType, opts?: CrudOptions) {
+  return crudEntries
+    .filter(([modelName]) => includeModel(modelName, opts))
+    .map(([modelName, config]) => {
+      const resolverEntries = Object.entries(config[type === "Query" ? "queries" : "mutations"]);
+
+      return resolverEntries.map(([operationName, resolverObjectDefiner]) => {
+        const resolverName = operationName + modelName;
+        const isntPrismaFieldList = ["count", "deleteMany", "updateMany"];
+        const isPrismaField = !isntPrismaFieldList.includes(operationName);
+
+        const getFields = (t: any) => {
+          const field = resolverObjectDefiner(t);
+          const handledField = opts?.handleResolver
+            ? opts.handleResolver({
+                field,
+                modelName: modelName as Model,
+                operationName,
+                resolverName,
+                t,
+                isPrismaField,
+                type,
+              })
+            : field;
+
+          return {
+            [resolverName]: isPrismaField
+              ? t.prismaField(handledField)
+              : t.field(handledField),
+          }
+        }
+
+        return type === "Query"
+          ? builder.queryFields((t) => getFields(t))
+          : builder.mutationFields((t) => getFields(t));
+      });
+    });
+}
+
+export function generateAllObjects(opts?: CrudOptions) {
+  return crudEntries
+    .filter(([md]) => includeModel(md, opts))
+    .map(([modelName, { Object }]) => {
+      return builder.prismaObject(modelName as Model, Object); // Objects is all imports
+    });
+}
+
+export function generateAllQueries(opts?: CrudOptions) {
+  generateResolversByType("Query", opts);
+}
+
+export function generateAllMutations(opts?: CrudOptions) {
+  generateResolversByType("Mutation", opts);
+}
+
+export function generateAllResolvers(opts?: CrudOptions) {
+  generateResolversByType("Mutation", opts);
+  generateResolversByType("Query", opts);
+}
+
+type CrudOptions = {
+  include?: Model[];
+  exclude?: Model[];
+  /**
+   * Caution: This is not type safe
+   * Wrap all queries/mutations to override args, run extra code in resolve function (ie: throw errors, logs), apply plugins, etc.
+   */
+  handleResolver?: (props: {
+    modelName: Model;
+    field: any;
+    operationName: string;
+    resolverName: string;
+    t: any;
+    isPrismaField: boolean;
+    type: ResolverType;
+  }) => any;
+};
+
+const includeModel = (model: string, opts?: CrudOptions): boolean => {
+  if (!opts) return true;
+  if (opts.include) return opts.include.includes(model as Model);
+  if (opts.exclude) return !opts.exclude.includes(model as Model);
+  return true;
+};
+
+export function generateAllCrud(opts?: CrudOptions) {
+  generateAllObjects(opts);
+  generateAllQueries(opts);
+  generateAllMutations(opts);
+}
+`;
+//# sourceMappingURL=root.js.map

package/src/crudGenerator/templates/root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","sourceRoot":"","sources":["../../../../src/crudGenerator/templates/root.ts"],"names":[],"mappings":";;;AAAa,QAAA,eAAe,GAAG;;;;;;;;;;;;;;CAc9B,CAAA;AAEY,QAAA,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6J5B,CAAA;AAED,0EAA0E;AAC1E;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6G/B,CAAA"}

package/src/crudGenerator/utils/generator.d.ts

@@ -0,0 +1,10 @@
+import { ConfigInternal } from '../../utils/config';
+import { GeneratedResolver, writeIndex } from './parts';
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * @returns List of generated resolvers
+ */
+export declare function generateModel(config: ConfigInternal, dmmf: DMMF.Document, modelName: string): Promise<{
+    resolvers: GeneratedResolver[];
+    index: Awaited<ReturnType<typeof writeIndex>>;
+}>;

package/src/crudGenerator/utils/generator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModel = generateModel;
+const mutation_1 = require("../templates/mutation");
+const query_1 = require("../templates/query");
+const parts_1 = require("./parts");
+/**
+ * @returns List of generated resolvers
+ */
+async function generateModel(config, dmmf, modelName) {
+    const model = dmmf.datamodel.models.find((m) => m.name === modelName);
+    if (!model)
+        return { index: [], resolvers: [] };
+    await (0, parts_1.writeObject)(config, model);
+    const queries = await (0, parts_1.writeResolvers)(config, model, 'queries', query_1.queries);
+    const mutations = await (0, parts_1.writeResolvers)(config, model, 'mutations', mutation_1.mutations);
+    const index = await (0, parts_1.writeIndex)(config, model, { queries, mutations });
+    return { resolvers: [...queries, ...mutations], index };
+}
+//# sourceMappingURL=generator.js.map

package/src/crudGenerator/utils/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../src/crudGenerator/utils/generator.ts"],"names":[],"mappings":";;AASA,sCAcC;AAtBD,oDAAsE;AACtE,8CAA8D;AAC9D,mCAAoF;AAGpF;;GAEG;AACI,KAAK,UAAU,aAAa,CACjC,MAAsB,EACtB,IAAmB,EACnB,SAAiB;IAEjB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAA;IACrE,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAA;IAE/C,MAAM,IAAA,mBAAW,EAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAChC,MAAM,OAAO,GAAG,MAAM,IAAA,sBAAc,EAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,eAAc,CAAC,CAAA;IAC9E,MAAM,SAAS,GAAG,MAAM,IAAA,sBAAc,EAAC,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,oBAAiB,CAAC,CAAA;IACrF,MAAM,KAAK,GAAG,MAAM,IAAA,kBAAU,EAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAA;IAErE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,OAAO,EAAE,GAAG,SAAS,CAAC,EAAE,KAAK,EAAE,CAAA;AACzD,CAAC"}

package/src/crudGenerator/utils/objectFields.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInternal } from '../../utils/config';
+import type { DMMF } from '@prisma/generator-helper';
+export declare const cleanifyDocumentation: (str?: string) => string | undefined;
+export declare const getObjectFieldsString: (modelName: string, fields: readonly DMMF.Field[], config: ConfigInternal) => {
+    fields: string[];
+    exportFields: string[];
+};