prisma-nestjs-graphql 21.1.1 → 21.2.0

package/generate.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var module$1 = require('module');
+var require$$0 = require('await-event-emitter');
 var assert = require('assert');
 var lodash = require('lodash');
 var tsMorph = require('ts-morph');
@@ -13,13 +13,6 @@ var filenamify = require('filenamify');
 var flat = require('flat');
 var pluralize = require('pluralize');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-var require$1 = (
-			false
-				? /* @__PURE__ */ module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('generate.cjs', document.baseURI).href)))
-				: require
-		);
-
 function isManyAndReturnOutputType(name) {
   const lowerName = name.toLowerCase();
   if ((lowerName.startsWith("createmany") || lowerName.startsWith("updatemany")) && (lowerName.endsWith("andreturnoutputtype") || lowerName.endsWith("andreturn"))) {
@@ -250,8 +243,8 @@ class ImportDeclarationMap extends Map {
     const value = {
       moduleSpecifier: from,
       namedImports: [],
-      defaultImport: undefined,
-      namespaceImport: undefined
+      defaultImport: void 0,
+      namespaceImport: void 0
     };
     if (namedImport === true && namespaceImport) {
       value.namedImports = [{ name: namespaceImport }];
@@ -284,7 +277,7 @@ async function generateFiles(args) {
   const { config, eventEmitter, output, project } = args;
   if (config.emitSingle) {
     const rootDirectory = project.getDirectory(output) || project.createDirectory(output);
-    const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts", undefined, { overwrite: true });
+    const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts", void 0, { overwrite: true });
     const statements = project.getSourceFiles().flatMap((s) => {
       if (s === sourceFile) {
         return [];
@@ -440,11 +433,11 @@ function getGraphqlImport(args) {
         return { name: typeName, specifier: "@nestjs/graphql" };
       }
       case "DateTime": {
-        return { name: "Date", specifier: undefined };
+        return { name: "Date", specifier: void 0 };
       }
       case "true":
       case "Boolean": {
-        return { name: "Boolean", specifier: undefined };
+        return { name: "Boolean", specifier: void 0 };
       }
       case "Decimal": {
         return {
@@ -456,7 +449,7 @@ function getGraphqlImport(args) {
         return { name: "GraphQLJSON", specifier: "graphql-type-json" };
       }
     }
-    return { name: "String", specifier: undefined };
+    return { name: "String", specifier: void 0 };
   }
   let sourceFileType = fileTypeByLocation(location);
   if (sourceFileType === "output" && fileType === "model") {
@@ -696,8 +689,8 @@ function inputType(args) {
     const property = propertyStructure({
       name,
       isNullable: !isRequired,
-      hasExclamationToken: hasExclamationToken || undefined,
-      hasQuestionToken: hasExclamationToken ? false : undefined,
+      hasExclamationToken: hasExclamationToken || void 0,
+      hasQuestionToken: hasExclamationToken ? false : void 0,
       propertyType,
       isList
     });
@@ -843,16 +836,16 @@ class ObjectSettings extends Array {
   }) {
     const fieldType = this.find((s) => s.kind === "FieldType");
     if (!fieldType) {
-      return undefined;
+      return void 0;
     }
     if (fieldType.match) {
-      return fieldType.match(name) ? fieldType : undefined;
+      return fieldType.match(name) ? fieldType : void 0;
     }
     if (input && !fieldType.input) {
-      return undefined;
+      return void 0;
     }
     if (output && !fieldType.output) {
-      return undefined;
+      return void 0;
     }
     return fieldType;
   }
@@ -863,16 +856,16 @@ class ObjectSettings extends Array {
   }) {
     const propertyType = this.find((s) => s.kind === "PropertyType");
     if (!propertyType) {
-      return undefined;
+      return void 0;
     }
     if (propertyType.match) {
-      return propertyType.match(name) ? propertyType : undefined;
+      return propertyType.match(name) ? propertyType : void 0;
     }
     if (input && !propertyType.input) {
-      return undefined;
+      return void 0;
     }
     if (output && !propertyType.output) {
-      return undefined;
+      return void 0;
     }
     return propertyType;
   }
@@ -926,7 +919,7 @@ function createObjectSettings(args) {
   }
   return {
     settings: result,
-    documentation: documentationLines.filter(Boolean).join("\n") || undefined
+    documentation: documentationLines.filter(Boolean).join("\n") || void 0
   };
 }
 function createSettingElement({
@@ -937,7 +930,7 @@ function createSettingElement({
 }) {
   const result = {
     documentLine: "",
-    element: undefined
+    element: void 0
   };
   if (line.startsWith("@deprecated")) {
     fieldElement.arguments["deprecationReason"] = lodash.trim(line.slice(11));
@@ -1033,9 +1026,9 @@ function hideFieldDecorator(match) {
     name: "HideField",
     arguments: [],
     from: "@nestjs/graphql",
-    defaultImport: undefined,
-    namespaceImport: undefined,
-    match: undefined
+    defaultImport: void 0,
+    namespaceImport: void 0,
+    match: void 0
   };
   if (!match.groups?.args) {
     result.output = true;
@@ -1070,8 +1063,8 @@ function parseArgs(string) {
   }
 }
 function getNamespace(name) {
-  if (name === undefined) {
-    return undefined;
+  if (name === void 0) {
+    return void 0;
   }
   let result = String(name);
   if (result.includes(".")) {
@@ -1260,7 +1253,7 @@ function modelOutputType(outputType, args) {
             ...settings?.fieldArguments(),
             defaultValue: ["number", "string", "boolean"].includes(
               typeof modelField?.default
-            ) ? modelField?.default : undefined,
+            ) ? modelField?.default : void 0,
             description: modelField?.documentation,
             nullable: Boolean(field.isNullable)
           })
@@ -1403,7 +1396,7 @@ function outputType(outputType2, args) {
   for (const field of outputType2.fields) {
     const { isList, location, type } = field.outputType;
     const outputTypeName = getOutputTypeName(String(type));
-    const settings = isCountOutput ? undefined : model && fieldSettings.get(model.name)?.get(field.name);
+    const settings = isCountOutput ? void 0 : model && fieldSettings.get(model.name)?.get(field.name);
     const propertySettings = settings?.getPropertyType({
       name: outputType2.name,
       output: true
@@ -1417,7 +1410,7 @@ function outputType(outputType2, args) {
       })
     );
     const property = propertyStructure({
-      hasQuestionToken: isCountOutput ? true : undefined,
+      hasQuestionToken: isCountOutput ? true : void 0,
       isList,
       isNullable: field.isNullable,
       name: field.name,
@@ -1616,19 +1609,41 @@ function getNamespaceExportDeclaration(directory, sourceDirectory) {
   };
 }
 
+function extractEnumValueDocs(values) {
+  return Object.fromEntries(
+    values.map((value) => {
+      const { name } = value;
+      const documentation = value.documentation;
+      if (typeof documentation !== "string") return null;
+      if (documentation.startsWith("@deprecated")) {
+        return [name, { deprecationReason: documentation.slice(11).trim() }];
+      }
+      return [name, { description: documentation }];
+    }).filter((entry) => entry !== null)
+  );
+}
+
 function registerEnum(enumType, args) {
-  const { getSourceFile, enums, config } = args;
+  const { config, enums, getSourceFile } = args;
   if (!config.emitBlocks.prismaEnums && !enums[enumType.name]) return;
   const dataModelEnum = enums[enumType.name];
+  const enumTypesData = dataModelEnum?.values || [];
   const sourceFile = getSourceFile({
     name: enumType.name,
     type: "enum"
   });
   const importDeclarations = new ImportDeclarationMap();
   importDeclarations.set("registerEnumType", {
-    namedImports: [{ name: "registerEnumType" }],
-    moduleSpecifier: "@nestjs/graphql"
+    moduleSpecifier: "@nestjs/graphql",
+    namedImports: [{ name: "registerEnumType" }]
   });
+  const valuesMap = extractEnumValueDocs(enumTypesData);
+  const filteredValuesMap = Object.fromEntries(
+    Object.entries(valuesMap).filter(([_, v]) => Object.keys(v).length > 0)
+  );
+  const hasValuesMap = Object.keys(filteredValuesMap).length > 0;
+  const formattedValuesMap = hasValuesMap ? JSON.stringify(filteredValuesMap, null, 2).replace(/"([^"]+)":/g, "$1:") : "";
+  const valuesMapEntry = hasValuesMap ? `, valuesMap: ${formattedValuesMap}` : "";
   const enumStructure = {
     kind: tsMorph.StructureKind.Enum,
     isExported: true,
@@ -1643,7 +1658,9 @@ function registerEnum(enumType, args) {
       ...importDeclarations.toStatements(),
       enumStructure,
       "\n",
-      `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(dataModelEnum?.documentation)} })`
+      `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(
+        dataModelEnum?.documentation
+      )}${valuesMapEntry} })`
     ]
   });
 }
@@ -1758,7 +1775,7 @@ function createConfig(data) {
       namedImport: toBoolean(element.namedImport),
       defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
       namespaceImport: element.namespaceImport,
-      arguments: element.arguments ? JSON5.parse(element.arguments) : undefined
+      arguments: element.arguments ? JSON5.parse(element.arguments) : void 0
     });
   }
   const customImport = [];
@@ -1825,7 +1842,7 @@ function createUseInputType(data) {
   for (const [typeName, useInputs] of Object.entries(data)) {
     const entry = {
       typeName,
-      ALL: undefined
+      ALL: void 0
     };
     if (useInputs.ALL) {
       entry.ALL = useInputs.ALL;
@@ -1879,7 +1896,7 @@ function factoryGetSourceFile(args) {
       template: outputFilePattern
     });
     filePath = `${output}/${filePath}`;
-    return project.getSourceFile(filePath) || project.createSourceFile(filePath, undefined, { overwrite: true });
+    return project.getSourceFile(filePath) || project.createSourceFile(filePath, void 0, { overwrite: true });
   };
 }
 
@@ -2005,7 +2022,7 @@ const middleKeywords = [
   ["OrderBy", "Args"]
 ];
 
-const AwaitEventEmitter = require$1("await-event-emitter").default;
+const AwaitEventEmitter = require$$0.default;
 async function generate(args) {
   const { connectCallback, dmmf, generator, skipAddOutputSourceFiles } = args;
   const generatorOutputValue = generator.output?.value;
@@ -2054,7 +2071,6 @@ async function generate(args) {
   const fieldSettings = /* @__PURE__ */ new Map();
   const getModelName = createGetModelName(modelNames);
   const getSourceFile = factoryGetSourceFile({
-    eventEmitter,
     getModelName,
     output: generatorOutputValue,
     outputFilePattern: config.outputFilePattern,

package/generate.d.ts

@@ -2,247 +2,287 @@ import { GeneratorOptions } from '@prisma/generator-helper';
 import AwaitEventEmitter from 'await-event-emitter';
 import { Project, SourceFile } from 'ts-morph';
 
+declare type Datamodel = ReadonlyDeep_2<{
+    models: Model$1[];
+    enums: DatamodelEnum[];
+    types: Model$1[];
+    indexes: Index[];
+}>;
+
+declare type DatamodelEnum = ReadonlyDeep_2<{
+    name: string;
+    values: EnumValue[];
+    dbName?: string | null;
+    documentation?: string;
+}>;
+
+declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum;
+
+declare type Deprecation = ReadonlyDeep_2<{
+    sinceVersion: string;
+    reason: string;
+    plannedRemovalVersion?: string;
+}>;
+
 declare namespace DMMF {
-    export type Document = ReadonlyDeep_2<{
-        datamodel: Datamodel;
-        schema: Schema;
-        mappings: Mappings;
-    }>;
-    export type Mappings = ReadonlyDeep_2<{
-        modelOperations: ModelMapping[];
-        otherOperations: {
-            read: string[];
-            write: string[];
-        };
-    }>;
-    export type OtherOperationMappings = ReadonlyDeep_2<{
+    export { datamodelEnumToSchemaEnum, type Document_2 as Document, type Mappings, type OtherOperationMappings, type DatamodelEnum, type SchemaEnum, type EnumValue, type Datamodel, type uniqueIndex, type PrimaryKey, type Model$1 as Model, type FieldKind, type FieldNamespace, type FieldLocation, type Field$1 as Field, type FieldDefault, type FieldDefaultScalar, type Index, type IndexType, type IndexField, type SortOrder, type Schema$1 as Schema, type Query, type QueryOutput, type TypeRef, type InputTypeRef, type SchemaArg, type OutputType, type SchemaField, type OutputTypeRef, type Deprecation, type InputType, type FieldRefType, type FieldRefAllowType, type ModelMapping, ModelAction }
+}
+
+declare type Document_2 = ReadonlyDeep_2<{
+    datamodel: Datamodel;
+    schema: Schema$1;
+    mappings: Mappings;
+}>;
+
+declare type EnumValue = ReadonlyDeep_2<{
+    name: string;
+    dbName: string | null;
+}>;
+
+declare type Field$1 = ReadonlyDeep_2<{
+    kind: FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    /**
+     * Describes the data type in the same the way it is defined in the Prisma schema:
+     * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
+     */
+    type: string;
+    /**
+     * Native database type, if specified.
+     * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
+     * `@db.Text` is encoded as `['Text', []]`.
+     */
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>;
+
+declare type FieldDefault = ReadonlyDeep_2<{
+    name: string;
+    args: Array<string | number>;
+}>;
+
+declare type FieldDefaultScalar = string | boolean | number;
+
+declare type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
+
+declare type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
+
+declare type FieldNamespace = 'model' | 'prisma';
+
+declare type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
+
+declare type FieldRefType = ReadonlyDeep_2<{
+    name: string;
+    allowTypes: FieldRefAllowType[];
+    fields: SchemaArg[];
+}>;
+
+declare type Index = ReadonlyDeep_2<{
+    model: string;
+    type: IndexType;
+    isDefinedOnField: boolean;
+    name?: string;
+    dbName?: string;
+    algorithm?: string;
+    clustered?: boolean;
+    fields: IndexField[];
+}>;
+
+declare type IndexField = ReadonlyDeep_2<{
+    name: string;
+    sortOrder?: SortOrder;
+    length?: number;
+    operatorClass?: string;
+}>;
+
+declare type IndexType = 'id' | 'normal' | 'unique' | 'fulltext';
+
+declare type InputType = ReadonlyDeep_2<{
+    name: string;
+    constraints: {
+        maxNumFields: number | null;
+        minNumFields: number | null;
+        fields?: string[];
+    };
+    meta?: {
+        source?: string;
+        grouping?: string;
+    };
+    fields: SchemaArg[];
+}>;
+
+declare type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
+
+declare type Mappings = ReadonlyDeep_2<{
+    modelOperations: ModelMapping[];
+    otherOperations: {
         read: string[];
         write: string[];
-    }>;
-    export type DatamodelEnum = ReadonlyDeep_2<{
-        name: string;
-        values: EnumValue[];
-        dbName?: string | null;
-        documentation?: string;
-    }>;
-    export type SchemaEnum = ReadonlyDeep_2<{
-        name: string;
-        values: string[];
-    }>;
-    export type EnumValue = ReadonlyDeep_2<{
-        name: string;
-        dbName: string | null;
-    }>;
-    export type Datamodel = ReadonlyDeep_2<{
-        models: Model[];
-        enums: DatamodelEnum[];
-        types: Model[];
-        indexes: Index[];
-    }>;
-    export type uniqueIndex = ReadonlyDeep_2<{
-        name: string;
-        fields: string[];
-    }>;
-    export type PrimaryKey = ReadonlyDeep_2<{
-        name: string | null;
-        fields: string[];
-    }>;
-    export type Model = ReadonlyDeep_2<{
-        name: string;
-        dbName: string | null;
-        schema: string | null;
-        fields: Field[];
-        uniqueFields: string[][];
-        uniqueIndexes: uniqueIndex[];
-        documentation?: string;
-        primaryKey: PrimaryKey | null;
-        isGenerated?: boolean;
-    }>;
-    export type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
-    export type FieldNamespace = 'model' | 'prisma';
-    export type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
-    export type Field = ReadonlyDeep_2<{
-        kind: FieldKind;
-        name: string;
-        isRequired: boolean;
-        isList: boolean;
-        isUnique: boolean;
-        isId: boolean;
-        isReadOnly: boolean;
-        isGenerated?: boolean;
-        isUpdatedAt?: boolean;
-        /**
-         * Describes the data type in the same the way it is defined in the Prisma schema:
-         * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
-         */
-        type: string;
-        /**
-         * Native database type, if specified.
-         * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
-         * `@db.Text` is encoded as `['Text', []]`.
-         */
-        nativeType?: [string, string[]] | null;
-        dbName?: string | null;
-        hasDefaultValue: boolean;
-        default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
-        relationFromFields?: string[];
-        relationToFields?: string[];
-        relationOnDelete?: string;
-        relationName?: string;
-        documentation?: string;
-    }>;
-    export type FieldDefault = ReadonlyDeep_2<{
-        name: string;
-        args: Array<string | number>;
-    }>;
-    export type FieldDefaultScalar = string | boolean | number;
-    export type Index = ReadonlyDeep_2<{
-        model: string;
-        type: IndexType;
-        isDefinedOnField: boolean;
-        name?: string;
-        dbName?: string;
-        algorithm?: string;
-        clustered?: boolean;
-        fields: IndexField[];
-    }>;
-    export type IndexType = 'id' | 'normal' | 'unique' | 'fulltext';
-    export type IndexField = ReadonlyDeep_2<{
-        name: string;
-        sortOrder?: SortOrder;
-        length?: number;
-        operatorClass?: string;
-    }>;
-    export type SortOrder = 'asc' | 'desc';
-    export type Schema = ReadonlyDeep_2<{
-        rootQueryType?: string;
-        rootMutationType?: string;
-        inputObjectTypes: {
-            model?: InputType[];
-            prisma: InputType[];
-        };
-        outputObjectTypes: {
-            model: OutputType[];
-            prisma: OutputType[];
-        };
-        enumTypes: {
-            model?: SchemaEnum[];
-            prisma: SchemaEnum[];
-        };
-        fieldRefTypes: {
-            prisma?: FieldRefType[];
-        };
-    }>;
-    export type Query = ReadonlyDeep_2<{
-        name: string;
-        args: SchemaArg[];
-        output: QueryOutput;
-    }>;
-    export type QueryOutput = ReadonlyDeep_2<{
-        name: string;
-        isRequired: boolean;
-        isList: boolean;
-    }>;
-    export type TypeRef<AllowedLocations extends FieldLocation> = {
-        isList: boolean;
-        type: string;
-        location: AllowedLocations;
-        namespace?: FieldNamespace;
     };
-    export type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
-    export type SchemaArg = ReadonlyDeep_2<{
-        name: string;
-        comment?: string;
-        isNullable: boolean;
-        isRequired: boolean;
-        inputTypes: InputTypeRef[];
-        deprecation?: Deprecation;
-    }>;
-    export type OutputType = ReadonlyDeep_2<{
-        name: string;
-        fields: SchemaField[];
-    }>;
-    export type SchemaField = ReadonlyDeep_2<{
-        name: string;
-        isNullable?: boolean;
-        outputType: OutputTypeRef;
-        args: SchemaArg[];
-        deprecation?: Deprecation;
-        documentation?: string;
-    }>;
-    export type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
-    export type Deprecation = ReadonlyDeep_2<{
-        sinceVersion: string;
-        reason: string;
-        plannedRemovalVersion?: string;
-    }>;
-    export type InputType = ReadonlyDeep_2<{
-        name: string;
-        constraints: {
-            maxNumFields: number | null;
-            minNumFields: number | null;
-            fields?: string[];
-        };
-        meta?: {
-            source?: string;
-        };
-        fields: SchemaArg[];
-    }>;
-    export type FieldRefType = ReadonlyDeep_2<{
-        name: string;
-        allowTypes: FieldRefAllowType[];
-        fields: SchemaArg[];
-    }>;
-    export type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
-    export type ModelMapping = ReadonlyDeep_2<{
-        model: string;
-        plural: string;
-        findUnique?: string | null;
-        findUniqueOrThrow?: string | null;
-        findFirst?: string | null;
-        findFirstOrThrow?: string | null;
-        findMany?: string | null;
-        create?: string | null;
-        createMany?: string | null;
-        createManyAndReturn?: string | null;
-        update?: string | null;
-        updateMany?: string | null;
-        updateManyAndReturn?: string | null;
-        upsert?: string | null;
-        delete?: string | null;
-        deleteMany?: string | null;
-        aggregate?: string | null;
-        groupBy?: string | null;
-        count?: string | null;
-        findRaw?: string | null;
-        aggregateRaw?: string | null;
-    }>;
-    export enum ModelAction {
-        findUnique = "findUnique",
-        findUniqueOrThrow = "findUniqueOrThrow",
-        findFirst = "findFirst",
-        findFirstOrThrow = "findFirstOrThrow",
-        findMany = "findMany",
-        create = "create",
-        createMany = "createMany",
-        createManyAndReturn = "createManyAndReturn",
-        update = "update",
-        updateMany = "updateMany",
-        updateManyAndReturn = "updateManyAndReturn",
-        upsert = "upsert",
-        delete = "delete",
-        deleteMany = "deleteMany",
-        groupBy = "groupBy",
-        count = "count",// TODO: count does not actually exist, why?
-        aggregate = "aggregate",
-        findRaw = "findRaw",
-        aggregateRaw = "aggregateRaw"
-    }
+}>;
+
+declare type Model$1 = ReadonlyDeep_2<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: Field$1[];
+    uniqueFields: string[][];
+    uniqueIndexes: uniqueIndex[];
+    documentation?: string;
+    primaryKey: PrimaryKey | null;
+    isGenerated?: boolean;
+}>;
+
+declare enum ModelAction {
+    findUnique = "findUnique",
+    findUniqueOrThrow = "findUniqueOrThrow",
+    findFirst = "findFirst",
+    findFirstOrThrow = "findFirstOrThrow",
+    findMany = "findMany",
+    create = "create",
+    createMany = "createMany",
+    createManyAndReturn = "createManyAndReturn",
+    update = "update",
+    updateMany = "updateMany",
+    updateManyAndReturn = "updateManyAndReturn",
+    upsert = "upsert",
+    delete = "delete",
+    deleteMany = "deleteMany",
+    groupBy = "groupBy",
+    count = "count",// TODO: count does not actually exist in DMMF
+    aggregate = "aggregate",
+    findRaw = "findRaw",
+    aggregateRaw = "aggregateRaw"
 }
 
+declare type ModelMapping = ReadonlyDeep_2<{
+    model: string;
+    plural: string;
+    findUnique?: string | null;
+    findUniqueOrThrow?: string | null;
+    findFirst?: string | null;
+    findFirstOrThrow?: string | null;
+    findMany?: string | null;
+    create?: string | null;
+    createMany?: string | null;
+    createManyAndReturn?: string | null;
+    update?: string | null;
+    updateMany?: string | null;
+    updateManyAndReturn?: string | null;
+    upsert?: string | null;
+    delete?: string | null;
+    deleteMany?: string | null;
+    aggregate?: string | null;
+    groupBy?: string | null;
+    count?: string | null;
+    findRaw?: string | null;
+    aggregateRaw?: string | null;
+}>;
+
+declare type OtherOperationMappings = ReadonlyDeep_2<{
+    read: string[];
+    write: string[];
+}>;
+
+declare type OutputType = ReadonlyDeep_2<{
+    name: string;
+    fields: SchemaField[];
+}>;
+
+declare type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
+
+declare type PrimaryKey = ReadonlyDeep_2<{
+    name: string | null;
+    fields: string[];
+}>;
+
+declare type Query = ReadonlyDeep_2<{
+    name: string;
+    args: SchemaArg[];
+    output: QueryOutput;
+}>;
+
+declare type QueryOutput = ReadonlyDeep_2<{
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+}>;
+
 declare type ReadonlyDeep_2<O> = {
     +readonly [K in keyof O]: ReadonlyDeep_2<O[K]>;
-};
+};
+
+declare type Schema$1 = ReadonlyDeep_2<{
+    rootQueryType?: string;
+    rootMutationType?: string;
+    inputObjectTypes: {
+        model?: InputType[];
+        prisma: InputType[];
+    };
+    outputObjectTypes: {
+        model: OutputType[];
+        prisma: OutputType[];
+    };
+    enumTypes: {
+        model?: SchemaEnum[];
+        prisma: SchemaEnum[];
+    };
+    fieldRefTypes: {
+        prisma?: FieldRefType[];
+    };
+}>;
+
+declare type SchemaArg = ReadonlyDeep_2<{
+    name: string;
+    comment?: string;
+    isNullable: boolean;
+    isRequired: boolean;
+    inputTypes: InputTypeRef[];
+    deprecation?: Deprecation;
+}>;
+
+declare type SchemaEnum = ReadonlyDeep_2<{
+    name: string;
+    values: string[];
+}>;
+
+declare type SchemaField = ReadonlyDeep_2<{
+    name: string;
+    isNullable?: boolean;
+    outputType: OutputTypeRef;
+    args: SchemaArg[];
+    deprecation?: Deprecation;
+    documentation?: string;
+}>;
+
+declare type SortOrder = 'asc' | 'desc';
+
+declare type TypeRef<AllowedLocations extends FieldLocation> = {
+    isList: boolean;
+    type: string;
+    location: AllowedLocations;
+    namespace?: FieldNamespace;
+};
+
+declare type uniqueIndex = ReadonlyDeep_2<{
+    name: string;
+    fields: string[];
+}>;
 
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).

package/index.cjs

@@ -2,7 +2,7 @@
 
 var generatorHelper = require('@prisma/generator-helper');
 var generate = require('./generate.cjs');
-require('module');
+require('await-event-emitter');
 require('assert');
 require('lodash');
 require('ts-morph');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-nestjs-graphql",
-  "version": "21.1.1",
+  "version": "21.2.0",
   "license": "MIT",
   "description": "Generate object types, inputs, args, etc. from prisma schema file for usage with @nestjs/graphql module",
   "bin": "bin.js",