prisma-nestjs-graphql 19.0.1 → 19.1.0

package/README.md

@@ -116,9 +116,18 @@ with temporal dead zone when generating merged file.
 Type: `boolean`  
 Default: `false`
 
-#### `purgeOutput`
+#### `emitBlocks`
+Emit only selected blocks. Be aware, that some blocks do depend on others, e.g. one can't emit `models` without emitting `enums`.  
+Type: `("args" | "inputs" | "outputs" | "models" | "enums")[]`  
+Default: `["args", "inputs", "outputs", "models", "enums"]`
 
-Delete all files in `output` folder  
+#### `omitModelsCount`
+Omit `_count` field from models.  
+Type: `boolean`  
+Default: `false`
+
+#### `purgeOutput`
+Delete all files in `output` folder.  
 Type: `boolean`  
 Default: `false`
 

package/generate.cjs

@@ -1159,6 +1159,8 @@ function modelOutputType(outputType, args) {
   importDeclarations.add("Field", nestjsGraphql$1);
   importDeclarations.add("ObjectType", nestjsGraphql$1);
   for (const field of outputType.fields) {
+    if (config.omitModelsCount && field.name === "_count")
+      continue;
     let fileType = "model";
     const { location, isList, type, namespace } = field.outputType;
     let outputTypeName = String(type);
@@ -1353,6 +1355,8 @@ function outputType(outputType2, args) {
   const model = models.get(modelName);
   const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType2.name) && String(outputType2.name).startsWith(model.name);
   const isCountOutput = (model == null ? void 0 : model.name) && outputType2.name === `${model.name}CountOutputType`;
+  if (!config.emitBlocks.outputs && !isCountOutput)
+    return;
   outputType2.name = getOutputTypeName(outputType2.name);
   if (isAggregateOutput) {
     eventEmitter.emitSync("AggregateOutput", { ...args, outputType: outputType2 });
@@ -1596,7 +1600,9 @@ function getNamespaceExportDeclaration(directory, sourceDirectory) {
 }
 
 function registerEnum(enumType, args) {
-  const { getSourceFile, enums } = args;
+  const { getSourceFile, enums, config } = args;
+  if (!config.emitBlocks.prismaEnums && !enums[enumType.name])
+    return;
   const dataModelEnum = enums[enumType.name];
   const sourceFile = getSourceFile({
     name: enumType.name,
@@ -1649,6 +1655,30 @@ function warning(message) {
   }
 }
 
+const allEmmittedBlocks = ["prismaEnums", "schemaEnums", "models", "inputs", "args", "outputs"];
+const blocksDependencyMap = {
+  enums: ["schemaEnums", "prismaEnums"],
+  models: ["models", "schemaEnums"],
+  inputs: ["inputs", "prismaEnums"],
+  outputs: ["outputs"],
+  args: ["args", "inputs", "prismaEnums"]
+};
+function createEmitBlocks(data) {
+  if (!data) {
+    return Object.fromEntries(allEmmittedBlocks.map((block) => [block, true]));
+  }
+  let blocksToEmit = {};
+  for (const block of data) {
+    if (!Object.keys(blocksDependencyMap).includes(block))
+      continue;
+    blocksToEmit = {
+      ...blocksToEmit,
+      ...Object.fromEntries(blocksDependencyMap[block].map((block2) => [block2, true]))
+    };
+  }
+  return blocksToEmit;
+}
+
 function createConfig(data) {
   var _a;
   const config = lodash.merge({}, flat.unflatten(data, { delimiter: "_" }));
@@ -1717,6 +1747,8 @@ function createConfig(data) {
     reExport: ReExport[String(config.reExport)] || ReExport.None,
     emitSingle: toBoolean(config.emitSingle),
     emitCompiled: toBoolean(config.emitCompiled),
+    emitBlocks: createEmitBlocks(config.emitBlocks),
+    omitModelsCount: toBoolean(config.omitModelsCount),
     $warnings,
     fields,
     purgeOutput: toBoolean(config.purgeOutput),
@@ -1929,17 +1961,21 @@ async function generate(args) {
   const { connectCallback, generator, skipAddOutputSourceFiles, dmmf } = args;
   const generatorOutputValue = (_a = generator.output) == null ? void 0 : _a.value;
   assert.ok(generatorOutputValue, "Missing generator configuration: output");
+  const config = createConfig(generator.config);
   const eventEmitter = new AwaitEventEmitter__default["default"]();
   eventEmitter.on("Warning", warning);
-  eventEmitter.on("Model", modelData);
-  eventEmitter.on("EnumType", registerEnum);
-  eventEmitter.on("OutputType", outputType);
-  eventEmitter.on("ModelOutputType", modelOutputType);
-  eventEmitter.on("AggregateOutput", createAggregateInput);
-  eventEmitter.on("InputType", inputType);
-  eventEmitter.on("ArgsType", argsType);
+  config.emitBlocks.models && eventEmitter.on("Model", modelData);
+  if (config.emitBlocks.prismaEnums || config.emitBlocks.schemaEnums) {
+    eventEmitter.on("EnumType", registerEnum);
+  }
+  if (config.emitBlocks.outputs || config.emitBlocks.models && !config.omitModelsCount) {
+    eventEmitter.on("OutputType", outputType);
+  }
+  config.emitBlocks.models && eventEmitter.on("ModelOutputType", modelOutputType);
+  config.emitBlocks.outputs && eventEmitter.on("AggregateOutput", createAggregateInput);
+  config.emitBlocks.inputs && eventEmitter.on("InputType", inputType);
+  config.emitBlocks.args && eventEmitter.on("ArgsType", argsType);
   eventEmitter.on("GenerateFiles", generateFiles);
-  const config = createConfig(generator.config);
   for (const message of config.$warnings) {
     eventEmitter.emitSync("Warning", message);
   }

package/generate.d.ts

@@ -82,7 +82,6 @@ declare namespace DMMF {
         relationOnDelete?: string;
         relationName?: string;
         documentation?: string;
-        [key: string]: any;
     }
     export interface FieldDefault {
         name: string;
@@ -118,25 +117,24 @@ declare namespace DMMF {
         isRequired: boolean;
         isList: boolean;
     }
-    export type ArgType = string | InputType | SchemaEnum;
-    export interface SchemaArgInputType {
+    export type TypeRef<AllowedLocations extends FieldLocation> = {
         isList: boolean;
-        type: ArgType;
-        location: FieldLocation;
+        type: string;
+        location: AllowedLocations;
         namespace?: FieldNamespace;
-    }
+    };
+    export type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
     export interface SchemaArg {
         name: string;
         comment?: string;
         isNullable: boolean;
         isRequired: boolean;
-        inputTypes: SchemaArgInputType[];
+        inputTypes: InputTypeRef[];
         deprecation?: Deprecation;
     }
     export interface OutputType {
         name: string;
         fields: SchemaField[];
-        fieldMap?: Record<string, SchemaField>;
     }
     export interface SchemaField {
         name: string;
@@ -146,23 +144,7 @@ declare namespace DMMF {
         deprecation?: Deprecation;
         documentation?: string;
     }
-    export type TypeRefCommon = {
-        isList: boolean;
-        namespace?: FieldNamespace;
-    };
-    export type TypeRefScalar = TypeRefCommon & {
-        location: 'scalar';
-        type: string;
-    };
-    export type TypeRefOutputObject = TypeRefCommon & {
-        location: 'outputObjectTypes';
-        type: OutputType | string;
-    };
-    export type TypeRefEnum = TypeRefCommon & {
-        location: 'enumTypes';
-        type: SchemaEnum | string;
-    };
-    export type OutputTypeRef = TypeRefScalar | TypeRefOutputObject | TypeRefEnum;
+    export type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
     export interface Deprecation {
         sinceVersion: string;
         reason: string;
@@ -179,14 +161,13 @@ declare namespace DMMF {
             source?: string;
         };
         fields: SchemaArg[];
-        fieldMap?: Record<string, SchemaArg>;
     }
     export interface FieldRefType {
         name: string;
         allowTypes: FieldRefAllowType[];
         fields: SchemaArg[];
     }
-    export type FieldRefAllowType = TypeRefScalar | TypeRefEnum;
+    export type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
     export interface ModelMapping {
         model: string;
         plural: string;
@@ -254,6 +235,8 @@ declare function createConfig(data: Record<string, unknown>): {
     reExport: ReExport;
     emitSingle: boolean;
     emitCompiled: boolean;
+    emitBlocks: Record<"models" | "inputs" | "args" | "outputs" | "prismaEnums" | "schemaEnums", boolean>;
+    omitModelsCount: boolean;
     $warnings: string[];
     fields: Record<string, Partial<Omit<ObjectSetting, "name">> | undefined>;
     purgeOutput: boolean;

package/package.json

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