@k0lyan/typegraphql-prisma-nestjs 0.28.20 → 0.28.21

package/lib/generator/generate-enhance.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnhanceMap = generateEnhanceMap;
+const ts_morph_1 = require("ts-morph");
+const config_1 = require("./config");
+function generateEnhanceMap(sourceFile, dmmfDocument, modelMappings, relationModels, models, inputs, outputs, generatorOptions) {
+    const hasRelations = relationModels.length > 0;
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "@nestjs/common",
+        namedImports: ["Type"],
+    });
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "tslib",
+        namespaceImport: "tslib",
+    });
+    if (dmmfDocument.shouldGenerateBlock("crudResolvers") ||
+        (hasRelations && dmmfDocument.shouldGenerateBlock("relationResolvers"))) {
+        sourceFile.addStatements(/* ts */ `
+      export type MethodDecoratorOverrideFn = (decorators: MethodDecorator[]) => MethodDecorator[];
+    `);
+    }
+    if (dmmfDocument.shouldGenerateBlock("crudResolvers")) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.crudResolversFolderName}/resolvers-crud.index`,
+            namespaceImport: "crudResolvers",
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.crudResolversFolderName}/args.index`,
+            namespaceImport: "argsTypes",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "crudResolversMap",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(modelMappings.map(mapping => [
+                        mapping.modelTypeName,
+                        `crudResolvers.${mapping.resolverName}`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.crudResolversFolderName}/resolvers-actions.index`,
+            namespaceImport: "actionResolvers",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "actionResolversMap",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(modelMappings.map(mapping => [
+                        mapping.modelTypeName,
+                        ts_morph_1.Writers.object(Object.fromEntries(mapping.actions
+                            .filter(a => !generatorOptions.emitActions?.includes(a.prismaMethod))
+                            .map(action => [
+                            action.name,
+                            `actionResolvers.${action.actionResolverName}`,
+                        ]))),
+                    ]))),
+                },
+            ],
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "crudResolversInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(modelMappings.map(mapping => [
+                        mapping.modelTypeName,
+                        `[${mapping.actions
+                            .filter(a => !generatorOptions.emitActions?.includes(a.prismaMethod))
+                            .map(action => `"${action.name}"`)
+                            .join(", ")}]`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        const actions = modelMappings
+            .flatMap(it => it.actions)
+            .filter(it => it.argsTypeName);
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "argsInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(actions.map(action => [
+                        action.argsTypeName,
+                        `[${action.method.args
+                            .map(arg => `"${arg.typeName}"`)
+                            .join(", ")}]`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addStatements(/* ts */ `
+      type ResolverModelNames = keyof typeof crudResolversMap;
+
+      type ModelResolverActionNames<
+        TModel extends ResolverModelNames
+        > = keyof typeof crudResolversMap[TModel]["prototype"];
+
+      export type ResolverActionsConfig<
+        TModel extends ResolverModelNames
+      > = Partial<Record<ModelResolverActionNames<TModel>, MethodDecorator[] | MethodDecoratorOverrideFn>>
+        & {
+          _all?: MethodDecorator[];
+          _query?: MethodDecorator[];
+          _mutation?: MethodDecorator[];
+        };
+
+      export type ResolversEnhanceMap = {
+        [TModel in ResolverModelNames]?: ResolverActionsConfig<TModel>;
+      };
+
+      export function applyResolversEnhanceMap(
+        resolversEnhanceMap: ResolversEnhanceMap,
+      ) {
+        const mutationOperationPrefixes = [
+          ${config_1.supportedMutationActions.map(it => `"${it}"`).join(", ")}
+        ];
+        for (const resolversEnhanceMapKey of Object.keys(resolversEnhanceMap)) {
+          const modelName = resolversEnhanceMapKey as keyof typeof resolversEnhanceMap;
+          const crudTarget = crudResolversMap[modelName].prototype;
+          const resolverActionsConfig = resolversEnhanceMap[modelName]!;
+          const actionResolversConfig = actionResolversMap[modelName];
+          const allActionsDecorators = resolverActionsConfig._all;
+          const resolverActionNames = crudResolversInfo[modelName as keyof typeof crudResolversInfo];
+          for (const resolverActionName of resolverActionNames) {
+            const maybeDecoratorsOrFn = resolverActionsConfig[
+              resolverActionName as keyof typeof resolverActionsConfig
+            ] as MethodDecorator[] | MethodDecoratorOverrideFn | undefined;
+            const isWriteOperation = mutationOperationPrefixes.some(prefix => resolverActionName.startsWith(prefix));
+            const operationKindDecorators = isWriteOperation ? resolverActionsConfig._mutation : resolverActionsConfig._query;
+            const mainDecorators = [
+              ...allActionsDecorators ?? [],
+              ...operationKindDecorators ?? [],
+            ]
+            let decorators: MethodDecorator[];
+            if (typeof maybeDecoratorsOrFn === "function") {
+              decorators = maybeDecoratorsOrFn(mainDecorators);
+            } else {
+              decorators = [...mainDecorators, ...maybeDecoratorsOrFn ?? []];
+            }
+            const actionTarget = (actionResolversConfig[
+              resolverActionName as keyof typeof actionResolversConfig
+            ] as Function).prototype;
+            tslib.__decorate(decorators, crudTarget, resolverActionName, null);
+            tslib.__decorate(decorators, actionTarget, resolverActionName, null);
+          }
+        }
+      }
+    `);
+        sourceFile.addStatements(/* ts */ `
+      type ArgsTypesNames = keyof typeof argsTypes;
+
+      type ArgFieldNames<TArgsType extends ArgsTypesNames> = Exclude<
+        keyof typeof argsTypes[TArgsType]["prototype"],
+        number | symbol
+      >;
+
+      type ArgFieldsConfig<
+        TArgsType extends ArgsTypesNames
+      > = FieldsConfig<ArgFieldNames<TArgsType>>;
+
+      export type ArgConfig<TArgsType extends ArgsTypesNames> = {
+        class?: ClassDecorator[];
+        fields?: ArgFieldsConfig<TArgsType>;
+      };
+
+      export type ArgsTypesEnhanceMap = {
+        [TArgsType in ArgsTypesNames]?: ArgConfig<TArgsType>;
+      };
+
+      export function applyArgsTypesEnhanceMap(
+        argsTypesEnhanceMap: ArgsTypesEnhanceMap,
+      ) {
+        for (const argsTypesEnhanceMapKey of Object.keys(argsTypesEnhanceMap)) {
+          const argsTypeName = argsTypesEnhanceMapKey as keyof typeof argsTypesEnhanceMap;
+          const typeConfig = argsTypesEnhanceMap[argsTypeName]!;
+          const typeClass = argsTypes[argsTypeName];
+          const typeTarget = typeClass.prototype;
+          applyTypeClassEnhanceConfig(
+            typeConfig,
+            typeClass,
+            typeTarget,
+            argsInfo[argsTypeName as keyof typeof argsInfo],
+          );
+        }
+      }
+    `);
+    }
+    if (hasRelations && dmmfDocument.shouldGenerateBlock("relationResolvers")) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.relationsResolversFolderName}/resolvers.index`,
+            namespaceImport: "relationResolvers",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "relationResolversMap",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(relationModels.map(relationModel => [
+                        relationModel.model.typeName,
+                        `relationResolvers.${relationModel.resolverName}`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "relationResolversInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(relationModels.map(relationModel => [
+                        relationModel.model.typeName,
+                        `[${relationModel.relationFields
+                            .map(field => `"${field.name}"`)
+                            .join(", ")}]`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addStatements(/* ts */ `
+      type RelationResolverModelNames = keyof typeof relationResolversMap;
+
+      type RelationResolverActionNames<
+        TModel extends RelationResolverModelNames
+        > = keyof typeof relationResolversMap[TModel]["prototype"];
+
+      export type RelationResolverActionsConfig<TModel extends RelationResolverModelNames>
+        = Partial<Record<RelationResolverActionNames<TModel>, MethodDecorator[] | MethodDecoratorOverrideFn>>
+        & { _all?: MethodDecorator[] };
+
+      export type RelationResolversEnhanceMap = {
+        [TModel in RelationResolverModelNames]?: RelationResolverActionsConfig<TModel>;
+      };
+
+      export function applyRelationResolversEnhanceMap(
+        relationResolversEnhanceMap: RelationResolversEnhanceMap,
+      ) {
+        for (const relationResolversEnhanceMapKey of Object.keys(relationResolversEnhanceMap)) {
+          const modelName = relationResolversEnhanceMapKey as keyof typeof relationResolversEnhanceMap;
+          const relationResolverTarget = relationResolversMap[modelName].prototype;
+          const relationResolverActionsConfig = relationResolversEnhanceMap[modelName]!;
+          const allActionsDecorators = relationResolverActionsConfig._all ?? [];
+          const relationResolverActionNames = relationResolversInfo[modelName as keyof typeof relationResolversInfo];
+          for (const relationResolverActionName of relationResolverActionNames) {
+            const maybeDecoratorsOrFn = relationResolverActionsConfig[
+              relationResolverActionName as keyof typeof relationResolverActionsConfig
+            ] as MethodDecorator[] | MethodDecoratorOverrideFn | undefined;
+            let decorators: MethodDecorator[];
+            if (typeof maybeDecoratorsOrFn === "function") {
+              decorators = maybeDecoratorsOrFn(allActionsDecorators);
+            } else {
+              decorators = [...allActionsDecorators, ...maybeDecoratorsOrFn ?? []];
+            }
+            tslib.__decorate(decorators, relationResolverTarget, relationResolverActionName, null);
+          }
+        }
+      }
+    `);
+    }
+    if (["outputs", "inputs", "models"].some(it => dmmfDocument.shouldGenerateBlock(it))) {
+        sourceFile.addStatements(/* ts */ `
+      type TypeConfig = {
+        class?: ClassDecorator[];
+        fields?: FieldsConfig;
+      };
+
+      export type PropertyDecoratorOverrideFn = (decorators: PropertyDecorator[]) => PropertyDecorator[];
+
+      type FieldsConfig<TTypeKeys extends string = string> = Partial<
+        Record<TTypeKeys, PropertyDecorator[] | PropertyDecoratorOverrideFn>
+      > & { _all?: PropertyDecorator[] };
+
+      function applyTypeClassEnhanceConfig<
+        TEnhanceConfig extends TypeConfig,
+        TType extends object
+      >(
+        enhanceConfig: TEnhanceConfig,
+        typeClass: Type<TType>,
+        typePrototype: TType,
+        typeFieldNames: string[]
+      ) {
+        if (enhanceConfig.class) {
+          tslib.__decorate(enhanceConfig.class, typeClass);
+        }
+        if (enhanceConfig.fields) {
+          const allFieldsDecorators = enhanceConfig.fields._all ?? [];
+          for (const typeFieldName of typeFieldNames) {
+            const maybeDecoratorsOrFn = enhanceConfig.fields[
+              typeFieldName
+            ] as PropertyDecorator[] | PropertyDecoratorOverrideFn | undefined;
+            let decorators: PropertyDecorator[];
+            if (typeof maybeDecoratorsOrFn === "function") {
+              decorators = maybeDecoratorsOrFn(allFieldsDecorators);
+            } else {
+              decorators = [...allFieldsDecorators, ...maybeDecoratorsOrFn ?? []];
+            }
+            tslib.__decorate(decorators, typePrototype, typeFieldName, void 0);
+          }
+        }
+      }
+    `);
+    }
+    if (dmmfDocument.shouldGenerateBlock("models")) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.modelsFolderName}`,
+            namespaceImport: "models",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "modelsInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(
+                    // TODO: support _count
+                    models.map(model => {
+                        const fieldsToEmit = model.fields.filter(field => !field.relationName && !field.isOmitted.output);
+                        return [
+                            model.typeName,
+                            `[${fieldsToEmit
+                                .map(field => `"${field.typeFieldAlias ?? field.name}"`)
+                                .join(", ")}]`,
+                        ];
+                    }))),
+                },
+            ],
+            isExported: true,
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addStatements(/* ts */ `
+      type ModelNames = keyof typeof models;
+
+      type ModelFieldNames<TModel extends ModelNames> = Exclude<
+        keyof typeof models[TModel]["prototype"],
+        number | symbol
+      >;
+
+      type ModelFieldsConfig<TModel extends ModelNames> = FieldsConfig<
+        ModelFieldNames<TModel>
+      >;
+
+      export type ModelConfig<TModel extends ModelNames> = {
+        class?: ClassDecorator[];
+        fields?: ModelFieldsConfig<TModel>;
+      };
+
+      export type ModelsEnhanceMap = {
+        [TModel in ModelNames]?: ModelConfig<TModel>;
+      };
+
+      export function applyModelsEnhanceMap(modelsEnhanceMap: ModelsEnhanceMap) {
+        for (const modelsEnhanceMapKey of Object.keys(modelsEnhanceMap)) {
+          const modelName = modelsEnhanceMapKey as keyof typeof modelsEnhanceMap;
+          const modelConfig = modelsEnhanceMap[modelName]!;
+          const modelClass = models[modelName];
+          const modelTarget = modelClass.prototype;
+          applyTypeClassEnhanceConfig(
+            modelConfig,
+            modelClass,
+            modelTarget,
+            modelsInfo[modelName as keyof typeof modelsInfo],
+          );
+        }
+      }
+    `);
+    }
+    if (dmmfDocument.shouldGenerateBlock("outputs")) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.outputsFolderName}`,
+            namespaceImport: "outputTypes",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "outputsInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(outputs.map(output => [
+                        output.typeName,
+                        `[${output.fields.map(field => `"${field.name}"`).join(", ")}]`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addStatements(/* ts */ `
+      type OutputTypesNames = keyof typeof outputTypes;
+
+      type OutputTypeFieldNames<TOutput extends OutputTypesNames> = Exclude<
+        keyof typeof outputTypes[TOutput]["prototype"],
+        number | symbol
+      >;
+
+      type OutputTypeFieldsConfig<
+        TOutput extends OutputTypesNames
+      > = FieldsConfig<OutputTypeFieldNames<TOutput>>;
+
+      export type OutputTypeConfig<TOutput extends OutputTypesNames> = {
+        class?: ClassDecorator[];
+        fields?: OutputTypeFieldsConfig<TOutput>;
+      };
+
+      export type OutputTypesEnhanceMap = {
+        [TOutput in OutputTypesNames]?: OutputTypeConfig<TOutput>;
+      };
+
+      export function applyOutputTypesEnhanceMap(
+        outputTypesEnhanceMap: OutputTypesEnhanceMap,
+      ) {
+        for (const outputTypeEnhanceMapKey of Object.keys(outputTypesEnhanceMap)) {
+          const outputTypeName = outputTypeEnhanceMapKey as keyof typeof outputTypesEnhanceMap;
+          const typeConfig = outputTypesEnhanceMap[outputTypeName]!;
+          const typeClass = outputTypes[outputTypeName];
+          const typeTarget = typeClass.prototype;
+          applyTypeClassEnhanceConfig(
+            typeConfig,
+            typeClass,
+            typeTarget,
+            outputsInfo[outputTypeName as keyof typeof outputsInfo],
+          );
+        }
+      }
+    `);
+    }
+    if (dmmfDocument.shouldGenerateBlock("inputs")) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: `./${config_1.resolversFolderName}/${config_1.inputsFolderName}`,
+            namespaceImport: "inputTypes",
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "inputsInfo",
+                    initializer: ts_morph_1.Writers.object(Object.fromEntries(inputs.map(input => [
+                        input.typeName,
+                        `[${input.fields
+                            .map(field => `"${field.typeName}"`)
+                            .join(", ")}]`,
+                    ]))),
+                },
+            ],
+            trailingTrivia: "\r\n",
+        });
+        sourceFile.addStatements(/* ts */ `
+      type InputTypesNames = keyof typeof inputTypes;
+
+      type InputTypeFieldNames<TInput extends InputTypesNames> = Exclude<
+        keyof typeof inputTypes[TInput]["prototype"],
+        number | symbol
+      >;
+
+      type InputTypeFieldsConfig<
+        TInput extends InputTypesNames
+      > = FieldsConfig<InputTypeFieldNames<TInput>>;
+
+      export type InputTypeConfig<TInput extends InputTypesNames> = {
+        class?: ClassDecorator[];
+        fields?: InputTypeFieldsConfig<TInput>;
+      };
+
+      export type InputTypesEnhanceMap = {
+        [TInput in InputTypesNames]?: InputTypeConfig<TInput>;
+      };
+
+      export function applyInputTypesEnhanceMap(
+        inputTypesEnhanceMap: InputTypesEnhanceMap,
+      ) {
+        for (const inputTypeEnhanceMapKey of Object.keys(inputTypesEnhanceMap)) {
+          const inputTypeName = inputTypeEnhanceMapKey as keyof typeof inputTypesEnhanceMap;
+          const typeConfig = inputTypesEnhanceMap[inputTypeName]!;
+          const typeClass = inputTypes[inputTypeName];
+          const typeTarget = typeClass.prototype;
+          applyTypeClassEnhanceConfig(
+            typeConfig,
+            typeClass,
+            typeTarget,
+            inputsInfo[inputTypeName as keyof typeof inputsInfo],
+          );
+        }
+      }
+    `);
+    }
+}
+//# sourceMappingURL=generate-enhance.js.map

package/lib/generator/generate-enhance.js.map

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

package/lib/generator/generate-helpers.d.ts

@@ -0,0 +1,3 @@
+import { SourceFile } from "ts-morph";
+import { GeneratorOptions } from "./options";
+export declare function generateHelpersFile(sourceFile: SourceFile, options: GeneratorOptions): void;

package/lib/generator/generate-helpers.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHelpersFile = generateHelpersFile;
+const imports_1 = require("./imports");
+function generateHelpersFile(sourceFile, options) {
+    (0, imports_1.generateGraphQLInfoImport)(sourceFile);
+    (0, imports_1.generateGraphQLFieldsImport)(sourceFile);
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "dataloader",
+        namespaceImport: "DataLoader",
+    });
+    sourceFile.addStatements(/* ts */ `
+    export function transformInfoIntoPrismaArgs(info: GraphQLResolveInfo, modelName?: string, collectionName?: string, prismaMethod?: string, isResolveField?: boolean): Record<string, any> {
+      const fields: Record<string, any> = graphqlFields(
+        // suppress GraphQLResolveInfo types issue
+        info as any,
+        {},
+        {
+          excludedFields: ['__typename'],
+          processArguments: true,
+        }
+      );
+      return transformFields(fields, modelName, collectionName, prismaMethod, isResolveField);
+    }
+  `);
+    sourceFile.addStatements(/* ts */ `
+    function transformFields(fields: Record<string, any>, modelName?: string, collectionName?: string, prismaMethod?: string, isResolveField?: boolean): Record<string, any> {
+      return Object.fromEntries(
+        Object.entries(fields)
+          .map<[string, any]>(([key, value]) => {
+            if (Object.keys(value).length === 0) {
+              return [key, true];
+            }
+            if ("__arguments" in value) {
+              return [key, Object.fromEntries(
+                value.__arguments.map((argument: object) => {
+                  const [[key, { value }]] = Object.entries(argument);
+                  return [key, value];
+                })
+              )];
+            }
+            return [key, transformFields(value, modelName, collectionName, prismaMethod, isResolveField)];
+          }),
+      );
+    }
+  `);
+    sourceFile.addStatements(/* ts */ `
+    export function getPrismaFromContext(context: any) {
+      const prismaClient = context["${options.contextPrismaKey}"];
+      if (!prismaClient) {
+        throw new Error("Unable to find Prisma Client in GraphQL context. Please provide it under the \`context[\\"${options.contextPrismaKey}\\"]\` key.");
+      }
+      return prismaClient;
+    }
+  `);
+    sourceFile.addStatements(/* ts */ `
+    export function transformCountFieldIntoSelectRelationsCount(_count: object, modelName?: string, collectionName?: string, prismaMethod?: string, isResolveField?: boolean) {
+      return {
+        include: {
+          _count: {
+            select: {
+              ...Object.fromEntries(
+                Object.entries(_count).filter(([_, v]) => v != null)
+              ),
+            }
+          },
+        },
+      }
+    }
+  `);
+    sourceFile.addStatements(/* ts */ `
+    export let transformArgsIntoPrismaArgs = async function <TArgs = Record<string, any>, TContext = any>(info: GraphQLResolveInfo, args: TArgs, ctx: TContext, modelName?: string, collectionName?: string, prismaMethod?: string, afterProcessEvents?: ((result:any) => Promise<any>)[], isResolveField?: boolean): Promise<TArgs> {
+        return args;
+    };
+
+    export function setTransformArgsIntoPrismaArgs(newTransformArgsIntoPrismaArgs: typeof transformArgsIntoPrismaArgs) {
+        transformArgsIntoPrismaArgs = newTransformArgsIntoPrismaArgs;
+    }
+  `);
+    sourceFile.addStatements(/* ts */ `
+/**
+ * Simple inline dataloader factory for type-graphql resolvers
+ * Creates a dataloader per request context
+ */
+export function InlineLoader<ID, Type>(
+  createLoader: (ctx: any) => DataLoader<ID, Type>,
+  _target: any,
+  _propertyKey: string,
+  parameterIndex: number
+) {
+  // This is a parameter decorator that creates dataloaders
+  // The actual loader creation happens at runtime in the resolver
+}
+
+/**
+ * Helper to get or create a dataloader from context
+ */
+export function getOrCreateLoader<ID, Type>(
+  ctx: any,
+  loaderKey: string,
+  createLoader: () => DataLoader<ID, Type>
+): DataLoader<ID, Type> {
+  if (!ctx._dataloaders) {
+    ctx._dataloaders = new Map();
+  }
+  if (!ctx._dataloaders.has(loaderKey)) {
+    ctx._dataloaders.set(loaderKey, createLoader());
+  }
+  return ctx._dataloaders.get(loaderKey);
+}
+  `);
+}
+//# sourceMappingURL=generate-helpers.js.map

package/lib/generator/generate-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-helpers.js","sourceRoot":"","sources":["../../src/generator/generate-helpers.ts"],"names":[],"mappings":";;AAOA,kDAoHC;AA1HD,uCAGmB;AAGnB,SAAgB,mBAAmB,CACjC,UAAsB,EACtB,OAAyB;IAEzB,IAAA,mCAAyB,EAAC,UAAU,CAAC,CAAC;IACtC,IAAA,qCAA2B,EAAC,UAAU,CAAC,CAAC;IACxC,UAAU,CAAC,oBAAoB,CAAC;QAC9B,eAAe,EAAE,YAAY;QAC7B,eAAe,EAAE,YAAY;KAC9B,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;;;;;;GAajC,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;GAoBjC,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;sCAEE,OAAO,CAAC,gBAAgB;;qHAEuD,OAAO,CAAC,gBAAgB;;;;GAI1I,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;GAcjC,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;GAQjC,CAAC,CAAC;IAEH,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BjC,CAAC,CAAC;AACL,CAAC"}

package/lib/generator/generate-scalars.d.ts

@@ -0,0 +1,3 @@
+import { SourceFile } from "ts-morph";
+import { GeneratorOptions } from "./options";
+export declare function generateCustomScalars(sourceFile: SourceFile, options: GeneratorOptions): void;

package/lib/generator/generate-scalars.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomScalars = generateCustomScalars;
+const imports_1 = require("./imports");
+function generateCustomScalars(sourceFile, options) {
+    (0, imports_1.generatePrismaNamespaceImport)(sourceFile, options);
+    (0, imports_1.generateGraphQLScalarTypeImport)(sourceFile);
+    sourceFile.addStatements(/* ts */ `
+    export const DecimalJSScalar = new GraphQLScalarType({
+      name: "Decimal",
+      description: "GraphQL Scalar representing the Prisma.Decimal type, based on Decimal.js library.",
+      serialize: (value: unknown) => {
+        if (!(Prisma.Decimal.isDecimal(value))) {
+          throw new Error(\`[DecimalError] Invalid argument: \${Object.prototype.toString.call(value)}. Expected Prisma.Decimal.\`);
+        }
+        return (value as Prisma.Decimal).toString();
+      },
+      parseValue: (value: unknown) => {
+        if (!(typeof value === "string")) {
+          throw new Error(\`[DecimalError] Invalid argument: \${typeof value}. Expected string.\`);
+        }
+        return new Prisma.Decimal(value);
+      },
+    });
+  `);
+}
+//# sourceMappingURL=generate-scalars.js.map

package/lib/generator/generate-scalars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-scalars.js","sourceRoot":"","sources":["../../src/generator/generate-scalars.ts"],"names":[],"mappings":";;AAQA,sDAyBC;AAhCD,uCAGmB;AAInB,SAAgB,qBAAqB,CACnC,UAAsB,EACtB,OAAyB;IAEzB,IAAA,uCAA6B,EAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACnD,IAAA,yCAA+B,EAAC,UAAU,CAAC,CAAC;IAE5C,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;GAiBjC,CAAC,CAAC;AACL,CAAC"}