@postxl/generator 0.74.1 → 1.0.1

package/dist/utils/vfs.class.js

@@ -0,0 +1,239 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualFileSystem = void 0;
+const fs = __importStar(require("fs/promises"));
+const minimatch_1 = require("minimatch");
+const utils_1 = require("@postxl/utils");
+const fs_utils_1 = require("./fs-utils");
+const Path = __importStar(require("./path"));
+/**
+ * The virtual file system (VFS) represents a file system that can be manipulated in memory.
+ *
+ * It exposes the following methods:
+ * - `write(path, content)`: Writes the given content to the given path
+ * - `read(path)`: Reads the content of the given path
+ * - `insertFromVfs(path, vfs)`: Inserts the content of the given VFS into the current VFS
+ * - `insertFromDisk(path, disk)`: Inserts the content of the given disk into the current VFS
+ * - `transform(fn, filter?)`: Transforms the content of all files in the VFS using the given function
+ *
+ * ## Implementation details
+ *
+ * All paths are relative to the root of the VFS - and are normalized to use the POSIX path separator.
+ * For this we use the `path` utils (path.normalize, path.join, path.parse). All paths are represented
+ * as branded strings (`Path.PosixPath`).
+ *
+ * The file content can either be a (UTF8) string or a Buffer.
+ *
+ * ## File Pattern Filtering
+ *
+ * The VFS can be configured with an optional file pattern filter during construction.
+ * When a pattern is set, only files matching the pattern will be stored in the VFS.
+ * This optimization ensures that linting, formatting, and lock file updates only affect
+ * the filtered files, significantly improving performance.
+ */
+class VirtualFileSystem {
+    #files = new Map();
+    #filePattern;
+    /**
+     * Constructs a new VirtualFileSystem.
+     *
+     * @param options - Optional configuration options for the VFS.
+     */
+    constructor(options) {
+        this.#filePattern = options?.filePattern;
+    }
+    /**
+     * Returns all file names in the VFS.
+     */
+    get fileNames() {
+        return Array.from(this.#files.keys()).toSorted((a, b) => a.localeCompare(b));
+    }
+    /**
+     * Returns all files in the VFS.
+     */
+    get files() {
+        // We return a new Map instance to prevent accidental mutations.
+        return new Map(this.#files);
+    }
+    /**
+     * Returns the file pattern filter if one is set.
+     */
+    get filePattern() {
+        return this.#filePattern;
+    }
+    /**
+     * Checks if a file path matches the VFS file pattern (if one is set).
+     * Returns true if no pattern is set, or if the path matches the pattern.
+     */
+    matchesPattern(filePath) {
+        if (!this.#filePattern) {
+            return true;
+        }
+        // Remove leading slash from filePath for consistent matching
+        const normalizedPath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        // Remove leading slash from pattern if present
+        const normalizedPattern = this.#filePattern.startsWith('/') ? this.#filePattern.slice(1) : this.#filePattern;
+        return (0, minimatch_1.minimatch)(normalizedPath, normalizedPattern, { dot: true, matchBase: false });
+    }
+    /**
+     * Writes the given content to the specified path.
+     * If a file pattern is set, only files matching the pattern will be stored.
+     */
+    write(path, content) {
+        const posixPath = Path.normalize(path);
+        // Skip files that don't match the pattern
+        if (!this.matchesPattern(posixPath)) {
+            return;
+        }
+        this.#files.set(posixPath, content);
+    }
+    /**
+     * Reads the content of a file from the specified path.
+     */
+    get(path) {
+        const posixPath = Path.normalize(path);
+        return this.#files.get(posixPath);
+    }
+    /**
+     * Reads the content of the specified folder.
+     */
+    getFolder(path) {
+        const posixPath = Path.normalize(path);
+        const vfs = new VirtualFileSystem();
+        for (const [filePath, content] of this.#files) {
+            if (filePath.startsWith(posixPath)) {
+                vfs.write(filePath.slice(posixPath.length), content);
+            }
+        }
+        if (vfs.fileNames.length === 0) {
+            return undefined;
+        }
+        return vfs;
+    }
+    /**
+     * Inserts the content of another VFS into this VFS at the specified path.
+     */
+    insertFromVfs({ vfs, targetPath = '.' }) {
+        const basePath = Path.normalize(targetPath);
+        for (const [filePath, content] of vfs.files) {
+            const combinedPath = Path.join(basePath, filePath);
+            // Skip files that don't match the pattern
+            if (!this.matchesPattern(combinedPath)) {
+                continue;
+            }
+            this.#files.set(combinedPath, content);
+        }
+    }
+    /**
+     * Loads the content from the folder on disk into this VFS at the specified path.
+     */
+    async loadFolder({ diskPath, targetPath = '.', recursive = true, filter, }) {
+        await this.#readDirectory({
+            diskPath: Path.normalize(diskPath),
+            targetPath: Path.normalize(targetPath),
+            filter,
+            recursive,
+        });
+    }
+    /**
+     * Loads the content from the file on disk into this VFS at the specified path.
+     */
+    async loadFile({ diskPath, targetPath }) {
+        const diskPathNormalized = Path.normalize(diskPath);
+        const basePath = Path.normalize(targetPath ?? Path.fileName(diskPathNormalized));
+        // Skip files that don't match the pattern
+        if (!this.matchesPattern(basePath)) {
+            return;
+        }
+        const content = await (0, fs_utils_1.readFile)(diskPathNormalized);
+        if (content.isErr()) {
+            console.error(`Error reading file: ${diskPath}`);
+            throw content.unwrapErr().error;
+        }
+        this.#files.set(basePath, content.unwrap());
+    }
+    async #readDirectory({ diskPath, targetPath, filter, recursive, }) {
+        const entries = await utils_1.Result.fromPromise(() => fs.readdir(diskPath, { withFileTypes: true }), () => `Folder "${diskPath}" does not exist`);
+        if (entries.isErr()) {
+            throw new Error(entries.unwrapErr());
+        }
+        for (const entry of entries.unwrap()) {
+            const entryName = Path.normalize(entry.name);
+            const entryPath = Path.join(diskPath, entryName);
+            const relativePath = Path.join(targetPath, entryName);
+            if (filter && !filter(relativePath)) {
+                continue;
+            }
+            if (recursive && entry.isDirectory()) {
+                await this.#readDirectory({ diskPath: entryPath, targetPath: relativePath, filter, recursive });
+            }
+            else if (entry.isFile()) {
+                // Skip files that don't match the pattern
+                if (!this.matchesPattern(relativePath)) {
+                    continue;
+                }
+                const content = await (0, fs_utils_1.readFile)(entryPath);
+                if (content.isErr()) {
+                    throw content.unwrapErr();
+                }
+                this.#files.set(relativePath, content.unwrap());
+            }
+        }
+    }
+    /**
+     * Transforms the content of all files using the provided function.
+     * An optional filter function can be provided to select specific files.
+     */
+    async transform(fn, { filter, onError, } = {}) {
+        for (const [path, content] of this.#files) {
+            if (!filter || filter(path)) {
+                try {
+                    const newContent = await fn({ content, path });
+                    this.#files.set(path, newContent);
+                }
+                catch (error) {
+                    if (onError) {
+                        onError({ path, content, error });
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+}
+exports.VirtualFileSystem = VirtualFileSystem;

package/dist/utils/zip.d.ts

@@ -0,0 +1,13 @@
+import JSZip from 'jszip';
+type ZipLimits = {
+    maxFiles: number;
+    maxSize: number;
+};
+/**
+ * Loads a zip file from a buffer and validates the number of files and the total size.
+ * Throws an error if the number of files or the total size exceeds the limits.
+ *
+ * This is to prevent malicious "zip bombs" (see Sonar rule S5042)
+ */
+export declare function loadZip(content: Buffer, limits?: ZipLimits): Promise<JSZip>;
+export {};

package/dist/utils/zip.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadZip = loadZip;
+const jszip_1 = __importDefault(require("jszip"));
+const defaultLimits = {
+    maxFiles: 1000,
+    maxSize: 100_000_000, // 100 MB
+};
+/**
+ * Loads a zip file from a buffer and validates the number of files and the total size.
+ * Throws an error if the number of files or the total size exceeds the limits.
+ *
+ * This is to prevent malicious "zip bombs" (see Sonar rule S5042)
+ */
+async function loadZip(content, limits = defaultLimits) {
+    const { maxFiles, maxSize } = limits;
+    let fileCount = 0;
+    let totalSize = 0;
+    const zip = new jszip_1.default();
+    await zip.loadAsync(content); // NOSONAR - the below code implements the suggested validation
+    const fileNames = Object.keys(zip.files);
+    for (const fileName of fileNames) {
+        fileCount++;
+        if (fileCount > maxFiles) {
+            throw new Error('Reached max. number of files');
+        }
+        const file = zip.file(fileName);
+        if (file) {
+            const fileContent = await file.async('nodebuffer');
+            totalSize += fileContent.length;
+            if (totalSize > maxSize) {
+                throw new Error('Reached max. size');
+            }
+        }
+    }
+    return zip;
+}

package/package.json

@@ -1,49 +1,72 @@
 {
   "name": "@postxl/generator",
-  "version": "0.74.1",
-  "main": "./dist/generator.js",
-  "typings": "./dist/generator.d.ts",
-  "bin": {
-    "@postxl/generator": "./dist/generator.js"
+  "version": "1.0.1",
+  "description": "Core package that orchestrates the code generation of a PXL project",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "PostXL GmbH",
+  "keywords": [
+    "postxl",
+    "pxl",
+    "generator",
+    "code-generation",
+    "typescript",
+    "nestjs",
+    "react"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "lint": "eslint .",
+    "prettier:check": "prettier --check \"**/*.{ts,tsx}\" --config ../../prettier.config.js --ignore-path ../../.prettierignore",
+    "test:jest": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest",
+    "test:coverage": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --coverage",
+    "test:watch": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --watch",
+    "test:types": "tsc --noEmit"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/postxl/postxl"
+    "url": "https://github.com/postxl/pxl",
+    "directory": "packages/generator"
   },
   "dependencies": {
-    "@faker-js/faker": "7.6.0",
-    "@prisma/generator-helper": "5.8.1",
-    "@prisma/internals": "5.8.1",
-    "exceljs": "4.3.0",
+    "@eslint/js": "9.10.0",
+    "@postxl/schema": "workspace:*",
+    "diff": "7.0.0",
     "fast-glob": "3.2.12",
-    "zod": "3.22.2",
-    "@postxl/lock": "1.5.0",
-    "@postxl/prettier": "0.1.0",
-    "@postxl/runtime": "0.1.5"
+    "globals": "15.12.0",
+    "isbinaryfile": "5.0.4",
+    "jszip": "3.10.1",
+    "minimatch": "^10.0.1",
+    "p-limit": "3.1.0"
   },
   "devDependencies": {
-    "@jest/globals": "29.7.0",
-    "@prisma/client": "5.8.1",
-    "@types/eslint": "8.44.7",
-    "@types/node": "20.5.0",
-    "jest": "29.7.0",
-    "prisma": "5.8.1",
-    "ts-jest": "29.1.3",
-    "ts-node": "10.9.2",
-    "ts-toolbelt": "9.6.0",
-    "tsconfig-paths": "4.2.0",
-    "typescript": "5.4.5"
-  },
-  "peerDependencies": {
-    "prisma": "5.8.1"
+    "@types/diff": "5.2.2",
+    "@types/eslint__js": "8.42.3"
   },
-  "scripts": {
-    "test:setup": "./scripts/test-setup.sh",
-    "test:jest": "jest",
-    "test:watch": "jest --watch",
-    "test:types": "tsc --noEmit"
+  "wallaby": {
+    "env": {
+      "type": "node",
+      "params": {
+        "runner": "--experimental-vm-modules"
+      }
+    }
   }
-}
+}

package/dist/generator.d.ts

@@ -1,13 +0,0 @@
-#! /usr/bin/env node
-import * as Schema from './lib/schema/schema';
-import { Logger } from './lib/utils/logger';
-/**
- * Generates PXL files and flushes them to disk.
- */
-export declare function generate({ models, enums, config, prismaClientPath, logger, }: {
-    models: Schema.Model[];
-    enums: Schema.Enum[];
-    config: Schema.SchemaConfig;
-    prismaClientPath: string;
-    logger: Logger;
-}): Promise<void>;