fix: Renamed config option

BREAKING CHANGE:
Inverted config option `atomicNumberOperations` to `noAtomicNumberOperations`
Replace `atomicNumberOperations = false` by `noAtomicNumberOperations = true`

README.md

@@ -42,8 +42,8 @@ npx prisma generate
     -   `{plural.type}` - plural short type name (models, inputs, enums)
 -   `combineScalarFilters` - Combine nested/nullable scalar filters to single
     (default: `true`)
--   `atomicNumberOperations` - Atomic number operations,
-    `false` - disabled (default), `true` - enabled
+-   `noAtomicNumberOperations` - Remove atomic number operations,
+    `true` (default), `false`
 -   `reExportAll` - create `index.ts` files for each directory with re-export,
     `false` - disabled (default), `true` - enabled
 -   `renameZooTypes` - Remove plague words from type names ('nullabe', 'nested')

src/generate-args.ts

@@ -1,12 +1,12 @@
 import { SourceFile } from 'ts-morph';
 
 import { generateInput } from './generate-input';
-import { GeneratorConfiguration, PrismaDMMF } from './types';
+import { GeneratorConfiguration, InputType } from './types';
 
 type GenerateArgsArguments = {
     feature: string;
-    inputType: PrismaDMMF.InputType;
-    aggregateInputs: PrismaDMMF.InputType[];
+    inputType: InputType;
+    aggregateInputs: InputType[];
     sourceFile: SourceFile;
     projectFilePath(data: { name: string; type: string }): string;
     config: GeneratorConfiguration;

src/generate-enum/generate-enum.ts

@@ -8,11 +8,11 @@ import {
 } from 'ts-morph';
 
 import { generateImport } from '../generate-import';
-import { PrismaDMMF } from '../types';
+import { SchemaEnum } from '../types';
 import { updateObjectProperty } from '../utils';
 
 type GenerateEnumArgs = {
-    enumerable: PrismaDMMF.SchemaEnum & { documentation?: string };
+    enumerable: SchemaEnum & { documentation?: string };
     sourceFile: SourceFile;
 };
 

src/generate-input/generate-input.ts

@@ -3,12 +3,12 @@ import { SourceFile } from 'ts-morph';
 import { DecoratorPropertyType, generateClass } from '../generate-class';
 import { generateImport, generateProjectImport } from '../generate-import';
 import { Field, generateProperty } from '../generate-property';
-import { GeneratorConfiguration, PrismaDMMF } from '../types';
+import { GeneratorConfiguration, InputType } from '../types';
 import { checkExport, fieldLocationToKind, toPropertyType } from '../utils';
 import { getMatchingInputType } from './get-matching-input-type';
 
 type GenerateInputArgs = {
-    inputType: PrismaDMMF.InputType;
+    inputType: InputType;
     sourceFile: SourceFile;
     projectFilePath(data: { name: string; type: string }): string;
     decorator: DecoratorPropertyType;

src/generate-input/get-matching-input-type.spec.ts

@@ -1,10 +1,10 @@
 import expect from 'expect';
 
-import { PrismaDMMF } from '../types';
+import { DMMF } from '../types';
 import { getMatchingInputType } from './get-matching-input-type';
 
 describe('get matching input type', () => {
-    let inputTypes: PrismaDMMF.SchemaArgInputType[] = [];
+    let inputTypes: DMMF.SchemaArgInputType[] = [];
     it('mixed types', () => {
         inputTypes = [
             {

src/generate-input/get-matching-input-type.ts

@@ -1,18 +1,18 @@
-import { PrismaDMMF } from '../types';
+import { DMMF } from '../types';
 import { fieldLocationToKind } from '../utils';
 
 /**
  * Find input type for graphql field decorator.
  */
-export function getMatchingInputType(inputTypes: PrismaDMMF.SchemaArgInputType[]) {
+export function getMatchingInputType(inputTypes: DMMF.SchemaArgInputType[]) {
     if (inputTypes.length === 0) {
         throw new Error('Cannot get matching input type from empty array');
     }
     if (inputTypes.length === 1) {
         return inputTypes[0];
     }
     inputTypes = inputTypes.filter(t => !['null', 'Null'].includes(String(t.type)));
-    let result: false | PrismaDMMF.SchemaArgInputType | undefined;
+    let result: false | DMMF.SchemaArgInputType | undefined;
     result =
         inputTypes.every(x => fieldLocationToKind(x.location) === 'object') &&
         (inputTypes.find(

src/generate.spec.ts

@@ -223,7 +223,7 @@ describe('main generate', () => {
               rating Float?
             }
             `,
-            options: [`atomicNumberOperations = false`],
+            options: [`noAtomicNumberOperations = true`],
         });
         for (const file of [
             'float-field-update-operations.input.ts',
@@ -284,7 +284,7 @@ describe('main generate', () => {
               rating Float?
             }
             `,
-            options: [`atomicNumberOperations = false`],
+            options: [`noAtomicNumberOperations = true`],
         });
         for (const file of [
             'aggregate-user.args.ts',
@@ -339,7 +339,7 @@ describe('main generate', () => {
 
     it('aggregate output types', async () => {
         await getResult({
-            options: [`atomicNumberOperations = false`],
+            options: [`noAtomicNumberOperations = true`],
             schema: `
             model User {
               id String @id
@@ -435,7 +435,7 @@ describe('main generate', () => {
         }
     });
 
-    it('option atomicNumberOperations false', async () => {
+    it('option noAtomicNumberOperations false', async () => {
         await getResult({
             schema: `
             model User {
@@ -451,7 +451,7 @@ describe('main generate', () => {
                 USER
             }
             `,
-            options: [`atomicNumberOperations = false`],
+            options: [`noAtomicNumberOperations = false`],
         });
         expect(sourceFiles.length).toBeGreaterThan(0);
         for (const sourceFile of sourceFiles) {

src/generate.ts

@@ -11,7 +11,7 @@ import { generateInput } from './generate-input';
 import { generateModel } from './generate-model';
 import { Model } from './generate-property';
 import { mutateFilters } from './mutate-filters';
-import { GeneratorConfiguration, PrismaDMMF } from './types';
+import { DMMF, GeneratorConfiguration } from './types';
 import {
     createConfig,
     featureName,
@@ -23,7 +23,7 @@ import {
 } from './utils';
 
 type GenerateArgs = GeneratorOptions & {
-    prismaClientDmmf?: PrismaDMMF.Document;
+    prismaClientDmmf?: DMMF.Document;
     fileExistsSync?: typeof existsSync;
     config?: GeneratorConfiguration;
 };
@@ -41,7 +41,7 @@ export async function generate(args: GenerateArgs) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         args.prismaClientDmmf ??
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        ((await import(prismaClientOutput)).dmmf as PrismaDMMF.Document);
+        ((await import(prismaClientOutput)).dmmf as DMMF.Document);
     const project = new Project({
         useInMemoryFileSystem: true,
         manipulationSettings: {
@@ -111,12 +111,11 @@ export async function generate(args: GenerateArgs) {
     }
     // Generate inputs
     let inputTypes = prismaClientDmmf.schema.inputObjectTypes.prisma;
-    inputTypes = inputTypes.filter(mutateFilters(inputTypes, config));
-    // Create aggregate inputs
     const aggregateInputs = prismaClientDmmf.schema.outputObjectTypes.prisma
         .filter(o => o.name.endsWith('AggregateOutputType'))
         .map(o => schemaOutputToInput(o));
     inputTypes = inputTypes.concat(aggregateInputs);
+    inputTypes = mutateFilters(inputTypes, config);
     inputTypes = uniqBy(inputTypes, x => x.name);
     for (const inputType of inputTypes) {
         const feature = featureName({
@@ -138,10 +137,11 @@ export async function generate(args: GenerateArgs) {
         });
     }
     // Generate args
-    const otherTypes = prismaClientDmmf.schema.outputObjectTypes.prisma
+    let otherTypes = prismaClientDmmf.schema.outputObjectTypes.prisma
         .filter(t => t.name === 'Query')
         .flatMap(t => t.fields)
         .map(field => schemaFieldToArgument(field));
+    otherTypes = mutateFilters(otherTypes, config);
     for (const inputType of otherTypes) {
         const feature = featureName({
             name: inputType.name,

src/mutate-filters/combine-scalar-filters.ts

@@ -1,4 +1,4 @@
-import { PrismaDMMF } from '../types';
+import { InputType } from '../types';
 import { renameInputs } from './rename-inputs';
 
 export function replacementTypeName(name: string) {
@@ -25,7 +25,7 @@ export function replacementTypeName(name: string) {
     return name;
 }
 
-export function combineScalarFilters(inputTypes: PrismaDMMF.InputType[]) {
+export function combineScalarFilters(inputTypes: InputType[]) {
     const replacements = Object.fromEntries(
         inputTypes
             .map(t => [t.name, replacementTypeName(t.name)])

src/mutate-filters/mutate-filters.ts

@@ -1,32 +1,18 @@
-import { PrismaDMMF } from '../types';
+import { GeneratorConfiguration, InputType } from '../types';
 import { combineScalarFilters } from './combine-scalar-filters';
 import { noAtomicNumberOperations } from './no-atomic-number-operations';
 import { renameZooTypes } from './rename-zoo-types';
 
-type MutateFiltersOptions = {
-    atomicNumberOperations?: boolean;
-    combineScalarFilters?: boolean;
-    renameZooTypes?: boolean;
-};
+export function mutateFilters(inputTypes: InputType[], config: GeneratorConfiguration) {
+    if (config.combineScalarFilters) {
+        inputTypes = inputTypes.map(combineScalarFilters(inputTypes));
+    }
+    if (config.noAtomicNumberOperations) {
+        inputTypes = inputTypes.filter(noAtomicNumberOperations());
+    }
+    if (config.renameZooTypes) {
+        inputTypes = inputTypes.map(renameZooTypes(inputTypes));
+    }
 
-export function mutateFilters(
-    inputTypes: PrismaDMMF.InputType[],
-    options: MutateFiltersOptions,
-) {
-    const mutations = [
-        options.combineScalarFilters && combineScalarFilters(inputTypes),
-        !options.atomicNumberOperations && noAtomicNumberOperations(),
-        options.renameZooTypes && renameZooTypes(inputTypes),
-    ].filter(Boolean);
-
-    return function (inputType: PrismaDMMF.InputType) {
-        for (const mutation of mutations) {
-            const result = mutation && mutation(inputType);
-            if (!result) {
-                return false;
-            }
-            inputType = result;
-        }
-        return inputType;
-    };
+    return inputTypes;
 }

src/mutate-filters/no-atomic-number-operations.ts

@@ -1,7 +1,7 @@
-import { PrismaDMMF } from '../types';
+import { InputType } from '../types';
 
 export function noAtomicNumberOperations() {
-    return (inputType: PrismaDMMF.InputType) => {
+    return (inputType: InputType) => {
         if (isAtomicOperation(inputType.name)) {
             return false;
         }

src/mutate-filters/rename-inputs.ts

@@ -1,7 +1,7 @@
-import { PrismaDMMF } from '../types';
+import { InputType } from '../types';
 
 export function renameInputs(replacements: Record<string, string>) {
-    return (inputType: PrismaDMMF.InputType) => {
+    return (inputType: InputType) => {
         const newTypeName = replacements[inputType.name];
         if (newTypeName) {
             inputType.name = newTypeName;

src/mutate-filters/rename-zoo-types.ts

@@ -1,4 +1,4 @@
-import { PrismaDMMF } from '../types';
+import { InputType } from '../types';
 import { renameInputs } from './rename-inputs';
 
 export function replacementTypeName(name: string) {
@@ -14,7 +14,7 @@ export function replacementTypeName(name: string) {
     return name;
 }
 
-export function renameZooTypes(inputTypes: PrismaDMMF.InputType[]) {
+export function renameZooTypes(inputTypes: InputType[]) {
     const replacements = Object.fromEntries(
         inputTypes
             .map(t => [t.name, replacementTypeName(t.name)])

src/testing/generator-options.ts

@@ -1,10 +1,10 @@
 import { GeneratorOptions } from '@prisma/generator-helper';
 import { exec } from 'child_process';
-import crypto from 'crypto';
 import findCacheDir from 'find-cache-dir';
 import fs from 'fs';
 
-import { PrismaDMMF } from '../types';
+import { DMMF } from '../types';
+import { generateHash } from '../utils';
 
 const {
     dependencies: { '@prisma/generator-helper': generatorVersion },
@@ -22,10 +22,9 @@ const cachePath: string = findCacheDir({
 export async function generatorOptions(
     schema: string,
     options?: string[],
-): Promise<GeneratorOptions & { prismaClientDmmf: PrismaDMMF.Document }> {
+): Promise<GeneratorOptions & { prismaClientDmmf: DMMF.Document }> {
     // eslint-disable-next-line prefer-rest-params
-    const data = JSON.stringify([generatorVersion, arguments]);
-    const hash = crypto.createHash('md5').update(data).digest('hex');
+    const hash = generateHash(generatorVersion, arguments);
     const optionsCacheFile = `${cachePath}/options-${hash}.js`;
     if (!fs.existsSync(optionsCacheFile)) {
         const schemaFile = `${cachePath}/schema-${hash}.prisma`;

src/types.ts

@@ -1,6 +1,14 @@
+import { DMMF } from '@prisma/client/runtime';
+
 import { createConfig } from './utils';
 
-export { DMMF as PrismaDMMF } from '@prisma/client/runtime';
+export { DMMF };
+
+export type InputType = DMMF.InputType;
+export type FieldLocation = DMMF.FieldLocation;
+export type OutputType = DMMF.OutputType;
+export type SchemaField = DMMF.SchemaField;
+export type SchemaEnum = DMMF.SchemaEnum;
 
 export type TypeRecord = Partial<{
     fieldType: string;

src/utils/create-config.spec.ts

@@ -10,7 +10,7 @@ describe('createConfig', () => {
     it('createConfig default', () => {
         const result = createConfig({});
         expect(result.combineScalarFilters).toEqual(true);
-        expect(result.atomicNumberOperations).toEqual(false);
+        expect(result.noAtomicNumberOperations).toEqual(true);
     });
 
     it('createConfig types', () => {

src/utils/create-config.ts

@@ -16,8 +16,8 @@ export function createConfig(data: Record<string, string | undefined>) {
         combineScalarFilters: ['true', '1', 'on'].includes(
             (config.combineScalarFilters as Nullable<string>) ?? 'true',
         ),
-        atomicNumberOperations: ['true', '1', 'on'].includes(
-            (config.atomicNumberOperations as Nullable<string>) ?? 'false',
+        noAtomicNumberOperations: ['true', '1', 'on'].includes(
+            (config.atomicNumberOperations as Nullable<string>) ?? 'true',
         ),
         types: merge(
             {},