prisma-nestjs-graphql 21.0.0 → 21.0.2

package/README.md

@@ -78,8 +78,6 @@ Default: `@prisma/client`
 
 #### `combineScalarFilters`
 
-DOESNT WORK IN v21+
-
 Combine nested/nullable scalar filters to single  
 Type: `boolean`  
 Default: `false`
@@ -764,3 +762,5 @@ import { generate } from 'prisma-nestjs-graphql/generate';
 
 - keyof typeof SortOrder -> `SortOrder`
 - dummy-createfriends.input.ts -> `create-friends`
+- check 'TODO FIXME'
+- 22.12 node require esm (update all deps to latest)

package/generate.cjs

@@ -184,7 +184,14 @@ function postBegin(args) {
       `${modelName}NullableRelationFilter`
     ]);
   }
-  lodash.remove(inputTypes, (inputType) => isContainBogus(inputType.name));
+  for (const modelName of modelNames) {
+    replaceBogusFilters(`${modelName}ScalarRelationFilter`, [
+      `${modelName}NullableScalarRelationFilter`
+    ]);
+  }
+  lodash.remove(inputTypes, (inputType) => {
+    return isContainBogus(inputType.name);
+  });
 }
 
 function createAggregateInput(args) {
@@ -274,7 +281,7 @@ class ImportDeclarationMap extends Map {
 }
 
 async function generateFiles(args) {
-  const { project, config, output, eventEmitter } = 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 });
@@ -325,9 +332,9 @@ async function generateFiles(args) {
           }
           if (statement.defaultImport) {
             imports.create({
+              defaultImport: statement.defaultImport,
               from: statement.moduleSpecifier,
-              name: statement.defaultImport,
-              defaultImport: statement.defaultImport
+              name: statement.defaultImport
             });
           }
           if (statement.namespaceImport) {
@@ -358,9 +365,9 @@ async function generateFiles(args) {
     project.compilerOptions.set({
       declaration: true,
       declarationDir: output,
-      rootDir: output,
-      outDir: output,
       emitDecoratorMetadata: false,
+      outDir: output,
+      rootDir: output,
       skipLibCheck: true
     });
     const emitResult = await project.emit();
@@ -409,12 +416,12 @@ function getGraphqlImport(args) {
   const {
     config,
     fileType,
-    location,
-    typeName,
+    getSourceFile,
     isId,
+    location,
     noTypeId,
     sourceFile,
-    getSourceFile
+    typeName
   } = args;
   if (location === "scalar") {
     if (isId && !noTypeId) {
@@ -455,8 +462,8 @@ function getGraphqlImport(args) {
   const specifier = relativePath(
     sourceFile.getFilePath(),
     getSourceFile({
-      type: sourceFileType,
-      name: typeName
+      name: typeName,
+      type: sourceFileType
     }).getFilePath()
   );
   return { name: typeName, specifier };
@@ -557,7 +564,8 @@ function getPropertyType(args) {
     return [type];
   }
   if (location === "enumTypes") {
-    return [`keyof typeof ${type}`];
+    const enumType = "`${" + type + "}`";
+    return [enumType];
   }
   if (location === "scalar") {
     return [type];
@@ -1353,9 +1361,13 @@ function isListInput(typeName, model, field) {
   return typeName === `${model}Create${field}Input` || typeName === `${model}Update${field}Input`;
 }
 
+function getEnumName(referenceName) {
+  return referenceName.slice(3, -2);
+}
+
 const nestjsGraphql = "@nestjs/graphql";
 function outputType(outputType2, args) {
-  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName, config } = args;
+  const { config, eventEmitter, fieldSettings, getModelName, getSourceFile, models } = args;
   const importDeclarations = new ImportDeclarationMap();
   const fileType = "output";
   const modelName = getModelName(outputType2.name) || "";
@@ -1372,21 +1384,21 @@ function outputType(outputType2, args) {
     type: fileType
   });
   const classStructure = {
-    kind: tsMorph.StructureKind.Class,
-    isExported: true,
-    name: outputType2.name,
     decorators: [
       {
-        name: "ObjectType",
-        arguments: []
+        arguments: [],
+        name: "ObjectType"
       }
     ],
+    isExported: true,
+    kind: tsMorph.StructureKind.Class,
+    name: outputType2.name,
     properties: []
   };
   importDeclarations.add("Field", nestjsGraphql);
   importDeclarations.add("ObjectType", nestjsGraphql);
   for (const field of outputType2.fields) {
-    const { location, isList, type } = field.outputType;
+    const { isList, location, type } = field.outputType;
     const outputTypeName = getOutputTypeName(String(type));
     const settings = isCountOutput ? undefined : model && fieldSettings.get(model.name)?.get(field.name);
     const propertySettings = settings?.getPropertyType({
@@ -1402,11 +1414,11 @@ function outputType(outputType2, args) {
       })
     );
     const property = propertyStructure({
-      name: field.name,
-      isNullable: field.isNullable,
       hasQuestionToken: isCountOutput ? true : undefined,
-      propertyType,
-      isList
+      isList,
+      isNullable: field.isNullable,
+      name: field.name,
+      propertyType
     });
     classStructure.properties?.push(property);
     if (propertySettings) {
@@ -1431,46 +1443,43 @@ function outputType(outputType2, args) {
     } else {
       const graphqlImport = getGraphqlImport({
         config,
-        sourceFile,
         fileType,
-        location,
+        getSourceFile,
         isId: false,
-        typeName: outputTypeName,
-        getSourceFile
+        location,
+        sourceFile,
+        typeName: outputTypeName
       });
+      const referenceName = location === "enumTypes" ? getEnumName(propertyType[0]) : propertyType[0];
       graphqlType = graphqlImport.name;
-      let referenceName = propertyType[0];
-      if (location === "enumTypes") {
-        referenceName = lodash.last(referenceName.split(" "));
-      }
       if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType2.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [{ name: graphqlImport.name }],
-          moduleSpecifier: graphqlImport.specifier
+          moduleSpecifier: graphqlImport.specifier,
+          namedImports: [{ name: graphqlImport.name }]
         });
       }
     }
     assert.ok(property.decorators, "property.decorators is undefined");
     if (shouldHideField) {
       importDeclarations.add("HideField", nestjsGraphql);
-      property.decorators.push({ name: "HideField", arguments: [] });
+      property.decorators.push({ arguments: [], name: "HideField" });
     } else {
       property.decorators.push({
-        name: "Field",
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
           JSON5.stringify({
             ...settings?.fieldArguments(),
             nullable: Boolean(field.isNullable)
           })
-        ]
+        ],
+        name: "Field"
       });
       if (isCustomsApplicable) {
         for (const options of settings || []) {
           if ((options.kind === "Decorator" && options.output && options.match?.(field.name)) ?? true) {
             property.decorators.push({
-              name: options.name,
-              arguments: options.arguments
+              arguments: options.arguments,
+              name: options.name
             });
             assert.ok(options.from, "Missed 'from' part in configuration or field setting");
             importDeclarations.create(options);
@@ -1479,8 +1488,8 @@ function outputType(outputType2, args) {
       }
     }
     eventEmitter.emitSync("ClassProperty", property, {
-      location,
       isList,
+      location,
       propertyType
     });
   }
@@ -1812,9 +1821,8 @@ function toBoolean(value) {
 }
 
 function generateFileName(args) {
-  const { template, type, name, getModelName } = args;
+  const { getModelName, name, template, type } = args;
   return pupa(template, {
-    type,
     get model() {
       const result = getModelName(name) || "prisma";
       return lodash.kebabCase(result);
@@ -1833,7 +1841,8 @@ function generateFileName(args) {
       get type() {
         return pluralize(type);
       }
-    }
+    },
+    type
   });
 }
 
@@ -1976,7 +1985,7 @@ const middleKeywords = [
 
 const AwaitEventEmitter = require$1("await-event-emitter").default;
 async function generate(args) {
-  const { connectCallback, generator, skipAddOutputSourceFiles, dmmf } = args;
+  const { connectCallback, dmmf, generator, skipAddOutputSourceFiles } = args;
   const generatorOutputValue = generator.output?.value;
   assert.ok(generatorOutputValue, "Missing generator configuration: output");
   const config = createConfig(generator.config);
@@ -1998,12 +2007,12 @@ async function generate(args) {
     eventEmitter.emitSync("Warning", message);
   }
   const project = new tsMorph.Project({
-    tsConfigFilePath: config.tsConfigFilePath,
-    skipAddingFilesFromTsConfig: true,
-    skipLoadingLibFiles: !config.emitCompiled,
     manipulationSettings: {
       quoteKind: tsMorph.QuoteKind.Single
-    }
+    },
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: !config.emitCompiled,
+    tsConfigFilePath: config.tsConfigFilePath
   });
   if (!skipAddOutputSourceFiles) {
     project.addSourceFilesAtPaths([
@@ -2023,30 +2032,30 @@ async function generate(args) {
   const fieldSettings = /* @__PURE__ */ new Map();
   const getModelName = createGetModelName(modelNames);
   const getSourceFile = factoryGetSourceFile({
-    output: generatorOutputValue,
-    project,
+    eventEmitter,
     getModelName,
+    output: generatorOutputValue,
     outputFilePattern: config.outputFilePattern,
-    eventEmitter
+    project
   });
   const { datamodel, schema } = JSON.parse(JSON.stringify(dmmf));
   const removeTypes = /* @__PURE__ */ new Set();
   const eventArguments = {
-    schema,
-    models,
+    classTransformerTypeModels: /* @__PURE__ */ new Set(),
     config,
-    modelNames,
-    modelFields,
-    fieldSettings,
-    project,
-    output: generatorOutputValue,
-    getSourceFile,
-    eventEmitter,
-    typeNames: /* @__PURE__ */ new Set(),
     enums: lodash.mapKeys(datamodel.enums, (x) => x.name),
+    eventEmitter,
+    fieldSettings,
     getModelName,
+    getSourceFile,
+    modelFields,
+    modelNames,
+    models,
+    output: generatorOutputValue,
+    project,
     removeTypes,
-    classTransformerTypeModels: /* @__PURE__ */ new Set()
+    schema,
+    typeNames: /* @__PURE__ */ new Set()
   };
   if (connectCallback) {
     await connectCallback(eventEmitter, eventArguments);
@@ -2058,7 +2067,7 @@ async function generate(args) {
   for (const model of datamodel.types || []) {
     await eventEmitter.emit("Model", model, eventArguments);
   }
-  const { inputObjectTypes, outputObjectTypes, enumTypes } = schema;
+  const { enumTypes, inputObjectTypes, outputObjectTypes } = schema;
   await eventEmitter.emit("PostBegin", eventArguments);
   for (const enumType of enumTypes.prisma.concat(enumTypes.model || [])) {
     await eventEmitter.emit("EnumType", enumType, eventArguments);
@@ -2078,9 +2087,9 @@ async function generate(args) {
   for (const inputType2 of inputTypes) {
     const event = {
       ...eventArguments,
-      inputType: inputType2,
+      classDecoratorName: "InputType",
       fileType: "input",
-      classDecoratorName: "InputType"
+      inputType: inputType2
     };
     if (inputType2.fields.length === 0) {
       removeTypes.add(inputType2.name);

package/package.json

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