@postxl/generator 0.71.1 → 0.72.0

package/dist/generator.js

@@ -32,13 +32,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generate = void 0;
+const assert_1 = __importDefault(require("assert"));
 const generator_helper_1 = require("@prisma/generator-helper");
 const internals_1 = require("@prisma/internals");
 const zod_1 = require("zod");
 const lock_1 = require("@postxl/lock");
 const prettier = __importStar(require("@postxl/prettier"));
+const runtime_1 = require("@postxl/runtime");
 const react_generator_1 = require("./generators/enums/react.generator");
 const types_generator_1 = require("./generators/enums/types.generator");
 const module_generator_1 = require("./generators/indices/data/module.generator");
@@ -75,6 +80,7 @@ const service_generator_5 = require("./generators/models/update/service.generato
 const service_generator_6 = require("./generators/models/view/service.generator");
 const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
+const types_2 = require("./lib/types");
 const client_path_1 = require("./prisma/client-path");
 const parse_1 = require("./prisma/parse");
 // NOTE: This needs to match the constant used in the manager package.
@@ -165,7 +171,6 @@ function generate(_a) {
         if (root == undefined) {
             throw new Error(`Could not find lock file. Make sure you are running the generator in a project folder.`);
         }
-        const gitignore = lock_1.GitIgnoreUtils.getGitignore(root);
         const generated = new prettier.ExtendedVirtualFS();
         // Generate Models
         for (const model of models) {
@@ -282,9 +287,9 @@ function generate(_a) {
                 },
             },
         });
-        const unfixableErrorCount = lintResult.totalErrorCount - lintResult.totalFixableErrorCount;
-        if (unfixableErrorCount > 0) {
-            console.log(`LINT: ${unfixableErrorCount} unfixable errors! Please open an issue with your schema!`);
+        const unFixableErrorCount = lintResult.totalErrorCount - lintResult.totalFixableErrorCount;
+        if (unFixableErrorCount > 0) {
+            console.log(`LINT: ${unFixableErrorCount} non-fixable errors! Please open an issue with your schema!`);
         }
         const unfixedWarningCount = lintResult.totalWarningCount - lintResult.totalFixableWarningCount;
         if (unfixedWarningCount > 0) {
@@ -295,17 +300,20 @@ function generate(_a) {
                 console.log(result.message);
             }
         }
-        if (unfixedWarningCount === 0 && unfixableErrorCount === 0) {
+        if (unfixedWarningCount === 0 && unFixableErrorCount === 0) {
             console.log(`LINT: All files linted successfully without warnings and errors!`);
         }
         yield generated.formatUTF8Files(prettier.config);
         // -------------------------------------------------------------------------
-        const vfs = yield lock_1.VirtualFS.fromLockFile({
-            root,
-            namespace: GENERATOR_NAMESPACE,
+        const gitignore = lock_1.GitIgnoreUtils.getGitignore(root);
+        const lock = yield lock_1.LockFile.fromProjectRoot({ root, namespace: GENERATOR_NAMESPACE });
+        const vfs = yield lock_1.VirtualFS.fromDirectory(root, {
             // NOTE: We start with a clean slate every time we generate so we can detect
             //       which files were not generated in the last run.
-            opts: { clean: true },
+            clean: true,
+            // NOTE: We only load files that may be impacted by the generator.
+            include: lock.listManagedFiles(),
+            ignore: [lock_1.LockFile.LOCKFILE_PATH],
         });
         // Merge with existing files.
         yield vfs.copy(generated, './');
@@ -316,11 +324,103 @@ function generate(_a) {
         if (FORCE_ENV) {
             console.debug('Forcing regeneration of all files due to POSTXL_FORCE_REWRITE=true!');
         }
-        const changes = yield vfs.flush(process.cwd(), GENERATOR_NAMESPACE, {
-            force: config.force || FORCE_ENV,
-            gitIgnoredFiles: gitignore === null || gitignore === void 0 ? void 0 : gitignore.entries,
-        });
-        const log = lock_1.ConsoleUtils.getFilesChangelog(changes.filter((c) => c.status !== 'skipped'));
+        const isForceMode = FORCE_ENV || config.force;
+        const results = yield vfs.flush(root, (_b) => __awaiter(this, [_b], void 0, function* ({ path, disk, file }) {
+            const fileLockEntry = lock.get(path);
+            switch (fileLockEntry.status) {
+                case 'unauthorized':
+                    // NOTE: We never override files that are not managed by the generator namespace!
+                    return 'skip';
+                case 'managed': {
+                    // NOTE: File is detached because developer changed the contents or deleted the file.
+                    if (
+                    // NOTE: User deleted the file!
+                    disk === undefined) {
+                        // NOTE: Unless the file is deleted because of gitignore or we are in force mode, we skip it.
+                        if ((gitignore === null || gitignore === void 0 ? void 0 : gitignore.entries.has(path)) || isForceMode) {
+                            return 'write';
+                        }
+                        return 'skip';
+                    }
+                    // NOTE: The file exists in the lock so we check whether it's managed or detached.
+                    const diskFileChecksum = yield lock_1.MiniGit.calculateFileChecksum({ path, content: disk.content });
+                    if (
+                    // NOTE: File is detached because developer changed the contents of the file.
+                    fileLockEntry.checksum !== diskFileChecksum) {
+                        // NOTE: We only skip detached files when we are not in force mode.
+                        if (isForceMode) {
+                            return 'write';
+                        }
+                        return 'skip';
+                    }
+                    // NOTE: File is managed!
+                    (0, assert_1.default)(fileLockEntry.checksum === diskFileChecksum && disk !== undefined);
+                    if (file) {
+                        const newFileChecksum = yield lock_1.MiniGit.calculateFileChecksum({
+                            path,
+                            content: file.kind === 'UTF8-FILE' ? file.utf8Content : file.binaryContent,
+                        });
+                        // NOTE: We defensively don't override files with matching checksums unless in force mode
+                        //       because checksum is by design not an injection.
+                        if (newFileChecksum === fileLockEntry.checksum && !isForceMode) {
+                            return 'skip';
+                        }
+                        return 'write';
+                    }
+                    // NOTE: File has been deleted.
+                    return 'write';
+                }
+                case 'enoent': {
+                    // NOTE: File has no lockfile entry.
+                    const is3rdPartFile = disk !== undefined;
+                    if (is3rdPartFile && !isForceMode) {
+                        return 'skip';
+                    }
+                    return 'write';
+                }
+                default:
+                    throw new types_2.ExhaustiveSwitchCheck(fileLockEntry);
+            }
+        }), { dryRun: false });
+        // NOTE: Lastly we update the lockfile with all changes we've flushed.
+        for (const change of results) {
+            switch (change.status) {
+                case 'write': {
+                    // NOTE: We update the lockfile entries of the files that were changed.
+                    if (change.disk === undefined) {
+                        lock.remove(change.path);
+                    }
+                    else {
+                        const r = yield lock.add({ path: change.path, content: change.disk.content });
+                        // NOTE: Adding a managed file should never fail.
+                        (0, assert_1.default)(r != null);
+                    }
+                    break;
+                }
+                case 'skip':
+                    break;
+                default:
+                    throw new types_2.ExhaustiveSwitchCheck(change);
+            }
+        }
+        yield lock.writeToProjectRoot(root, { dryRun: false });
+        // NOTE: Lastly we generate the log of the changes.
+        const log = lock_1.ConsoleUtils.getFilesChangelog(results.map((result) => {
+            if (result.status === 'write') {
+                if (result.prevDisk === undefined) {
+                    return { path: result.path, status: 'new' };
+                }
+                if (result.disk === undefined) {
+                    return { path: result.path, status: 'deleted' };
+                }
+                if (runtime_1.BufferUtils.equals(result.prevDisk.content, result.disk.content) &&
+                    result.prevDisk.mode === result.disk.mode) {
+                    return { path: result.path, status: 'unchanged' };
+                }
+                return { path: result.path, status: 'changed' };
+            }
+            return { path: result.path, status: 'skipped' };
+        }));
         console.info(log);
     });
 }

package/dist/generators/indices/import/service.generator.js

@@ -26,9 +26,11 @@ function generateImportService({ models, meta }) {
         [meta.actions.execution.interfaceLocation.import]: [meta.actions.execution.interface],
         [meta.actions.dispatcher.classLocation.import]: [meta.actions.dispatcher.class],
         [types.location.path]: [
+            (0, types_1.toAnnotatedTypeName)(delta),
             (0, types_1.toAnnotatedTypeName)(delta_Fields),
             (0, types_1.toAnnotatedTypeName)(delta_Model.type),
-            (0, types_1.toAnnotatedTypeName)(delta),
+            (0, types_1.toAnnotatedTypeName)(delta_Model.errors.invalidReference.type),
+            (0, types_1.toAnnotatedTypeName)(delta_Model.errors.isRequiredDependency.type),
         ],
         [decoder.location.path]: [(0, types_1.toAnnotatedTypeName)(decoder.decodedPXLModelDataTypeName)],
         [converterFunctions.location.path]: [converterFunctions.deltaToBulkMutations],
@@ -266,10 +268,10 @@ export class ${meta.import.importService.name} {
   /**
    * Internal helper function that removes undefined values from an array.
    */
-  private keepErrors<ModelErrors>(errors: (ModelErrors | undefined)[]): ModelErrors[] {
-    return errors.filter((error) => error !== undefined) as ModelErrors[]
+  private keepErrors<O, I extends O | undefined>(errors: I[]): O[] {
+    return errors.filter((error) => error !== undefined) as O[]
   }
-
+  
   private validateRequiredFields<
     Model extends ${dto.genericModel}<ID>, 
     ID extends ${dto.idType}, 
@@ -492,10 +494,6 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
         }
         else if (field.kind === 'relation') {
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
-            imports.addTypeImport({
-                from: schemaMeta.import.types.location.path,
-                items: [delta_Model.errors.invalidReference.type],
-            });
             sharedValidations.push(`this.validateReferenceField({
           item,
           fieldName: '${fieldName}',
@@ -515,10 +513,6 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
                 !relatedField.isRequired) {
                 continue;
             }
-            imports.addTypeImport({
-                from: schemaMeta.import.types.location.path,
-                items: [delta_Model.errors.isRequiredDependency.type],
-            });
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
             const relatedFieldName = (0, string_1.toPascalCase)(relatedField.name);
             deleteValidations.push(`
@@ -566,12 +560,13 @@ private async detect${modelMeta.internalSingularNameCapitalized}Delta(
           existingItem,
           properties: [${fieldNames.join(',')}],
         }),
-      validateCreate: async ({ item }) =>
+      validateCreate: async ({ item }): Promise<${modelMeta.import.delta_Model_Errors}[]> =>
         this.keepErrors([
           ${requiredFieldsValidation}
           ...(await sharedValidations(item)),
         ]),
-      validateUpdate: async ({ item }) => this.keepErrors(await sharedValidations(item)),
+      validateUpdate: async ({ item }): Promise<${modelMeta.import.delta_Model_Errors}[]> => 
+        this.keepErrors(await sharedValidations(item)),
       validateDelete: ${validateDelete},
     })
 }`;

package/dist/generators/models/repository.generator.js

@@ -831,7 +831,7 @@ function generateValidationBlocks({ model }) {
 function generateIndexBlocks({ model, imports }) {
     const indexes = model.attributes.index ? [getIndexDefinition({ fieldNames: model.attributes.index, model })] : [];
     if (indexes.length > 0) {
-        imports.addTypeImport({ from: (0, types_1.toPackageName)('@postxl/runtime'), items: [(0, types_1.toTypeName)('NestedMap')] });
+        imports.addImport({ items: [(0, types_1.toClassName)('NestedMap')], from: (0, types_1.toPackageName)('@postxl/runtime') });
     }
     const result = {
         nestedMapDeclarations: [],

package/dist/prisma/parse.js

@@ -241,6 +241,9 @@ function parseModel({ dmmfModel, enums, models, config, }) {
                 validation = { type: 'float' };
             }
             const _field = Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
+            if (_field.tsTypeName === 'boolean' && !_field.isRequired) {
+                (0, error_1.throwError)(`${(0, logger_1.highlight)(`${dmmfModel.name}.${fieldName}`)}: Boolean fields cannot be nullable!`);
+            }
             return _field;
         }
         if (dmmfField.kind === 'enum') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.71.1",
+  "version": "0.72.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -19,10 +19,10 @@
     "@prisma/internals": "5.8.1",
     "exceljs": "4.3.0",
     "fast-glob": "3.2.12",
-    "remeda": "1.9.4",
     "zod": "3.22.2",
-    "@postxl/lock": "1.4.2",
-    "@postxl/prettier": "0.0.2"
+    "@postxl/lock": "1.5.0",
+    "@postxl/prettier": "0.1.0",
+    "@postxl/runtime": "0.1.3"
   },
   "devDependencies": {
     "@jest/globals": "29.7.0",
@@ -40,11 +40,9 @@
   "peerDependencies": {
     "prisma": "5.8.1"
   },
-  "wallaby": {
-    "autoDetect": true
-  },
   "scripts": {
-    "test:generators": "./scripts/test.sh",
+    "test:generators": "./scripts/test-generators.sh",
+    "test:setup": "./scripts/test-setup.sh",
     "test:jest": "jest",
     "test:watch": "jest --watch",
     "test:types": "tsc --noEmit"