@postxl/generator 0.35.0 → 0.37.0

package/dist/generator.js

@@ -56,24 +56,25 @@ const stub_generator_1 = require("./generators/models/stub.generator");
 const types_generator_3 = require("./generators/models/types.generator");
 const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
-const client_path_1 = require("./prisma/client-path");
-const parse_1 = require("./prisma/parse");
-const datamocker_generator_1 = require("./generators/indices/datamocker.generator");
-const businesslogic_update_service_generator_1 = require("./generators/indices/businesslogic-update-service.generator");
+const vfs_1 = require("./lib/vfs");
+const businesslogic_actiontypes_generator_1 = require("./generators/indices/businesslogic-actiontypes.generator");
 const businesslogic_update_index_generator_1 = require("./generators/indices/businesslogic-update-index.generator");
 const businesslogic_update_module_generator_1 = require("./generators/indices/businesslogic-update-module.generator");
+const businesslogic_update_service_generator_1 = require("./generators/indices/businesslogic-update-service.generator");
+const businesslogic_view_index_generator_1 = require("./generators/indices/businesslogic-view-index.generator");
+const businesslogic_view_module_generator_1 = require("./generators/indices/businesslogic-view-module.generator");
+const businesslogic_view_service_generator_1 = require("./generators/indices/businesslogic-view-service.generator");
+const datamocker_generator_1 = require("./generators/indices/datamocker.generator");
+const dispatcher_service_generator_1 = require("./generators/indices/dispatcher-service.generator");
+const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
+const seed_service_generator_1 = require("./generators/indices/seed-service.generator");
 const seed_template_decoder_generator_1 = require("./generators/indices/seed-template-decoder.generator");
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
-const seed_service_generator_1 = require("./generators/indices/seed-service.generator");
-const dispatcher_service_generator_1 = require("./generators/indices/dispatcher-service.generator");
-const businesslogic_actiontypes_generator_1 = require("./generators/indices/businesslogic-actiontypes.generator");
 const seeddata_type_generator_1 = require("./generators/indices/seeddata-type.generator");
-const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
-const businesslogic_view_generator_1 = require("./generators/models/businesslogic-view.generator");
 const businesslogic_update_generator_1 = require("./generators/models/businesslogic-update.generator");
-const businesslogic_view_service_generator_1 = require("./generators/indices/businesslogic-view-service.generator");
-const businesslogic_view_module_generator_1 = require("./generators/indices/businesslogic-view-module.generator");
-const businesslogic_view_index_generator_1 = require("./generators/indices/businesslogic-view-index.generator");
+const businesslogic_view_generator_1 = require("./generators/models/businesslogic-view.generator");
+const client_path_1 = require("./prisma/client-path");
+const parse_1 = require("./prisma/parse");
 const CONFIG_SCHEMA = zod_1.z
     .object({
     project: zod_1.z.string(),
@@ -158,8 +159,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         if (root == undefined) {
             throw new Error(`Could not find lock file. Make sure you are running the generator in a project folder.`);
         }
-        const vfs = yield lock_1.VirtualFS.fromLockFile(root);
-        const generated = new lock_1.VirtualFS();
+        const vfs = yield vfs_1.ExtendedVirtualFS.fromLockFile(root);
+        const generated = new vfs_1.ExtendedVirtualFS();
         // Generate Models
         for (const model of models) {
             const meta = (0, meta_1.getModelMetadata)({ model });
@@ -189,7 +190,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             }
             // React
             if (!config.disableGenerators.react) {
-                generated.copy((0, react_generator_2.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
+                yield generated.copy((0, react_generator_2.generateReactComponentsForModel)({ model, meta }), meta.react.folderPath);
             }
             logger.log(`- ${model.name} processed`);
         }
@@ -200,7 +201,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
                 generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_1.generateEnumType)({ enumerator, prismaClientPath, meta }));
             }
             if (!config.disableGenerators.react) {
-                generated.copy((0, react_generator_1.generateEnumReactComponents)({ enumerator, meta }), meta.react.folderPath);
+                yield generated.copy((0, react_generator_1.generateEnumReactComponents)({ enumerator, meta }), meta.react.folderPath);
             }
         }
         // Generate Index Files and Services
@@ -249,11 +250,51 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         // -------------------------------------------------------------------------
         // Add disclaimer and format.
         const prettierConfig = yield prettier.resolveConfig(process.cwd());
-        generated.transformUTF8Files((path, content) => `${DISCLAIMER}\n${content}`);
-        generated.formatUTF8Files(prettierConfig);
+        yield generated.transformUTF8Files((path, content) => `${DISCLAIMER}\n${content}`);
+        yield generated.formatUTF8Files(prettierConfig);
+        const lintResult = yield generated.lintUTF8Files({
+            fix: true,
+            useEslintrc: false,
+            allowInlineConfig: true,
+            extensions: ['.ts', '.tsx', '.js', '.jsx'],
+            overrideConfig: {
+                parser: '@typescript-eslint/parser',
+                extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+                plugins: ['@typescript-eslint'],
+                parserOptions: {
+                    sourceType: 'module',
+                    ecmaVersion: 'latest',
+                },
+                env: {
+                    es2022: true,
+                    node: true,
+                },
+                rules: {
+                    // The "curly" rule ensures that all if, else if, else, for, while, or do blocks are followed by a block in braces, even if it is only a single line.
+                    // This will flag `if(condition) return x` and expect it to be written as `if (condition) { return x }`
+                    curly: ['error', 'all'],
+                },
+            },
+        });
+        const unfixableErrorCount = lintResult.totalErrorCount - lintResult.totalFixableErrorCount;
+        if (unfixableErrorCount > 0) {
+            console.log(`LINT: ${unfixableErrorCount} unfixable errors! Please open an issue with your schema!`);
+        }
+        const unfixedWarningCount = lintResult.totalWarningCount - lintResult.totalFixableWarningCount;
+        if (unfixedWarningCount > 0) {
+            console.log(`LINT: ${unfixedWarningCount} unfixed warnings! Please open an issue with your schema!`);
+        }
+        for (const [, result] of lintResult.results) {
+            if (result.errorCount > 0 || result.warningCount > 0) {
+                console.log(result.message);
+            }
+        }
+        if (unfixedWarningCount === 0 && unfixableErrorCount === 0) {
+            console.log(`LINT: All files linted successfully without warnings and errors!`);
+        }
         // -------------------------------------------------------------------------
         // Merge with existing files.
-        vfs.copy(generated, './');
+        yield vfs.copy(generated, './');
         // Flush to disk.
         // NOTE: We use a special "internal" variable to force regeneration of all files so that
         //       the template files are always up to date.

package/dist/generators/indices/businesslogic-view-service.generator.js

@@ -21,14 +21,14 @@ function generateBusinessLogicViewService({ models, meta }) {
         .map(({ meta }) => `@Inject(forwardRef(() => ${meta.businessLogic.view.serviceClassName}))  public readonly ${meta.businessLogic.view.serviceVariableName} :${meta.businessLogic.view.serviceClassName}`)
         .join(',\n');
     return `
-  import { Inject, Injectable, forwardRef } from '@nestjs/common'
+import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
-  ${imports.generate()}
+${imports.generate()}
 
-  @Injectable()
-  export class ${meta.businessLogic.view.serviceClassName} {
-    constructor(${constructor}) {}
-  }
+@Injectable()
+export class ${meta.businessLogic.view.serviceClassName} {
+  constructor(${constructor}) {}
+}
   `;
 }
 exports.generateBusinessLogicViewService = generateBusinessLogicViewService;

package/dist/generators/indices/datamocker.generator.js

@@ -23,13 +23,15 @@ function generateDataMocker({ models, meta: schemaMeta }) {
         .map(({ model, meta }) => `private ${meta.data.dataServiceIdName}Ids = new IdTracker<${model.typeName}>()`)
         .join('\n');
     const addDataFunctions = modelMetas.map(({ model, meta }) => generateAddDataFunction(model, meta)).join('\n');
-    // const timeNow = new Date().toLocaleTimeString('en-US', { hour12: false, hour: 'numeric', minute: 'numeric' })
-    // const todayDate = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'numeric', day: 'numeric' })
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import type { MockData } from '@pxl/data'
-import { IdTracker } from './id-tracker.class'
+
 ${imports.generate()}
 
+import { IdTracker } from './id-tracker.class'
+
+
 export class DataMocker implements MockData {
   ${publicVariables}
 
@@ -40,38 +42,46 @@ export class DataMocker implements MockData {
 `;
 }
 exports.generateDataMocker = generateDataMocker;
-// Generated time stamp: ${todayDate} ${timeNow}
 function generateAddDataFunction(model, meta) {
     const { fields, idField } = model;
-    const relations = fields.filter(schema_1.isFieldRelation).map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }), model: field.relationToModel })));
-    return `public add${model.typeName}(item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName}}>): DataMocker {
-    const initial${meta.data.dataServiceIdName} = stub${model.typeName}(item ?? {})
-    this.${meta.data.dataServiceName}.push(this.${meta.data.dataServiceIdName}Ids.ensureId(initial${meta.data.dataServiceIdName}))
-    const ${meta.data.dataServiceIdName} = this.${meta.data.dataServiceName}[this.${meta.data.dataServiceName}.length - 1]
-    ${relations
-        .map((r) => `
-        ${r.isRequired
-        ? `
-            if (${meta.data.dataServiceIdName}.${r.name}) {
-                if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
-                    this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
-                }
-            } else {
-                if (this.${r.meta.data.dataServiceName}.length === 0) {
-                  this.add${r.model.typeName}()
-                }
-                ${meta.data.dataServiceIdName}.${r.name} = this.${r.meta.data.dataServiceName}[0].id
-              }
-        `
-        : `
-            if (${meta.data.dataServiceIdName}.${r.name}) {
-              if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === ${meta.data.dataServiceIdName}.${r.name}) === -1 ) {
-                  this.add${r.model.typeName}({ id: ${meta.data.dataServiceIdName}.${r.name} })
-              }
-            }
-            `}
-    `)
-        .join('\n')}
+    const relations = fields
+        .filter(schema_1.isFieldRelation)
+        .map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }), model: field.relationToModel })))
+        .map((r) => {
+        if (r.isRequired) {
+            return `
+        if (_item.${r.name}) {
+          if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === _item.${r.name}) === -1) {
+            this.add${r.model.typeName}({ id: _item.${r.name} })
+          }
+        } else {
+          if (this.${r.meta.data.dataServiceName}.length === 0) {
+            this.add${r.model.typeName}()
+          }
+          _item.${r.name} = this.${r.meta.data.dataServiceName}[0].id
+        }
+      `;
+        }
+        return `
+      if (_item.${r.name}) {
+        if (this.${r.meta.data.dataServiceName}.findIndex((x) => x.id === _item.${r.name}) === -1) {
+          this.add${r.model.typeName}({ id: _item.${r.name} })
+        }
+      }
+    `;
+    });
+    // TODO: Move the publicly accessible function's name to the metadata definition!
+    return `
+  public add${model.typeName}(
+    item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName} }>
+  ): DataMocker {
+    const _stub = stub${model.typeName}(item ?? {})
+    const _item = this.${meta.data.dataServiceIdName}Ids.ensureId(_stub)
+    
+    this.${meta.data.dataServiceName}.push(_item)
+    
+    ${relations.join('\n')}
+    
     return this
   }`;
 }

package/dist/generators/indices/dispatcher-service.generator.js

@@ -33,7 +33,7 @@ import { Action, ResultOfAction } from './actions.types'
 export class DispatcherService {
   // as the SeedModule gets instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
   // we set the seedService to a dummy value and then overwrite it in the ${meta.seed.serviceClassName} constructor.
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
   public seedService: ${meta.seed.serviceClassName} = {} as unknown as any
   constructor(
     private readonly updateService: ${meta.businessLogic.update.serviceClassName}, 

package/dist/generators/models/businesslogic-view.generator.js

@@ -93,6 +93,7 @@ function generateModelBusinessLogicView({ model, meta }) {
     }
   `;
     return `
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { FilterOperator } from '@pxl/common'
 

package/dist/lib/vfs.d.ts

@@ -0,0 +1,33 @@
+import { ESLint } from 'eslint';
+import * as prettier from 'prettier';
+import { VirtualFS as BaseVirtualFS, PathUtils } from '@postxl/lock';
+type FileLintResult = {
+    fixableErrorCount: number;
+    errorCount: number;
+    fixableWarningCount: number;
+    warningCount: number;
+    message: string;
+};
+/**
+ * A utility class that also contains formatting and linting functionality.
+ */
+export declare class ExtendedVirtualFS extends BaseVirtualFS {
+    constructor();
+    /**
+     * Formats the file system using configuration in the given directory.
+     */
+    formatUTF8Files(options?: prettier.Options | null): Promise<void>;
+    /**
+     * Lints the file system using provided configuration and returns the result as a map.
+     *
+     * NOTE: If the `fix` option is set to `true` in `ESLint.Options`, the files will be modified in-place.
+     */
+    lintUTF8Files(options: ESLint.Options): Promise<{
+        totalFixableErrorCount: number;
+        totalErrorCount: number;
+        totalFixableWarningCount: number;
+        totalWarningCount: number;
+        results: Map<PathUtils.PosixPath, FileLintResult>;
+    }>;
+}
+export {};

package/dist/lib/vfs.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedVirtualFS = void 0;
+const eslint_1 = require("eslint");
+const nodepath = __importStar(require("node:path"));
+const prettier = __importStar(require("prettier"));
+const lock_1 = require("@postxl/lock");
+/**
+ * A utility class that also contains formatting and linting functionality.
+ */
+class ExtendedVirtualFS extends lock_1.VirtualFS {
+    constructor() {
+        super();
+    }
+    /**
+     * Formats the file system using configuration in the given directory.
+     */
+    formatUTF8Files(options = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transformUTF8Files((path, content) => {
+                const ext = nodepath.extname(path);
+                let parser = undefined;
+                switch (ext) {
+                    case '.js':
+                    case '.jsx':
+                        parser = 'babel';
+                        break;
+                    case '.ts':
+                    case '.tsx':
+                        parser = 'typescript';
+                        break;
+                    case '.json':
+                        parser = 'json';
+                        break;
+                    case '.md':
+                        parser = 'markdown';
+                        break;
+                    case '.html':
+                        parser = 'html';
+                        break;
+                }
+                if (parser == null) {
+                    return content;
+                }
+                try {
+                    return prettier.format(content, Object.assign(Object.assign({}, options), { parser }));
+                }
+                catch (err) {
+                    console.error(`${content}\n\nFailed to format ${path}\n\n`);
+                    throw err;
+                }
+            });
+        });
+    }
+    /**
+     * Lints the file system using provided configuration and returns the result as a map.
+     *
+     * NOTE: If the `fix` option is set to `true` in `ESLint.Options`, the files will be modified in-place.
+     */
+    lintUTF8Files(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eslint = new eslint_1.ESLint(options);
+            const _results = new Map();
+            const formatter = yield eslint.loadFormatter('stylish');
+            yield this.transformUTF8Files((path, content) => __awaiter(this, void 0, void 0, function* () {
+                const ext = nodepath.extname(path);
+                switch (ext) {
+                    case '.js':
+                    case '.jsx':
+                    case '.ts':
+                    case '.tsx': {
+                        try {
+                            const results = yield eslint.lintText(content, { filePath: path });
+                            if (results.length !== 1) {
+                                // https://eslint.org/docs/latest/integrate/nodejs-api#return-value-1
+                                // NOTE: The docs explicitly state that "This is an array (despite there being
+                                //       only one lint result) in order to keep the interfaces between this and
+                                //       the eslint.lintFiles() method similar.".
+                                throw new Error(`Expected ESLint to return exactly one result, but got ${results.length} instead.`);
+                            }
+                            const message = yield formatter.format(results);
+                            const [result] = results;
+                            _results.set(path, {
+                                fixableErrorCount: result.fixableErrorCount,
+                                errorCount: result.errorCount,
+                                fixableWarningCount: result.fixableWarningCount,
+                                warningCount: result.warningCount,
+                                message,
+                            });
+                            if (result.output) {
+                                return result.output;
+                            }
+                            return content;
+                        }
+                        catch (err) {
+                            console.error(`${content}\n\nFailed to format ${path}\n\n`);
+                            throw err;
+                        }
+                    }
+                    default: {
+                        return content;
+                    }
+                }
+            }));
+            let totalFixableErrorCount = 0;
+            let totalErrorCount = 0;
+            let totalFixableWarningCount = 0;
+            let totalWarningCount = 0;
+            for (const result of _results.values()) {
+                totalFixableErrorCount += result.fixableErrorCount;
+                totalErrorCount += result.errorCount;
+                totalFixableWarningCount += result.fixableWarningCount;
+                totalWarningCount += result.warningCount;
+            }
+            return {
+                totalFixableErrorCount,
+                totalErrorCount,
+                totalFixableWarningCount,
+                totalWarningCount,
+                results: _results,
+            };
+        });
+    }
+}
+exports.ExtendedVirtualFS = ExtendedVirtualFS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -17,15 +17,20 @@
     "@faker-js/faker": "7.6.0",
     "@prisma/generator-helper": "^5.2.0",
     "@prisma/internals": "^5.2.0",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "@typescript-eslint/utils": "^6.10.0",
+    "eslint": "^8.53.0",
     "exceljs": "^4.3.0",
     "fast-glob": "^3.2.12",
-    "prettier": "^2.8.8",
+    "prettier": "^3.0.3",
     "remeda": "1.9.4",
     "zod": "3.21.4",
-    "@postxl/lock": "0.4.9"
+    "@postxl/lock": "1.0.0"
   },
   "devDependencies": {
     "@prisma/client": "^5.2.0",
+    "@types/eslint": "^8.44.7",
     "@types/jest": "^29.5.0",
     "@types/node": "18.15.10",
     "jest": "29.5.0",