@comet/admin-generator 8.17.1 → 9.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comet/admin-generator",
-  "version": "8.17.1",
+  "version": "9.0.0-beta.0",
   "description": "Comet Admin Generator CLI tool",
   "repository": {
     "directory": "packages/admin/admin-generator",
@@ -8,48 +8,59 @@
     "url": "https://github.com/vivid-planet/comet"
   },
   "license": "BSD-2-Clause",
-  "type": "commonjs",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
   "bin": {
-    "comet-admin-generator": "bin/admin-generator.js"
+    "comet-admin-generator": "bin/admin-generator.mjs"
   },
   "files": [
-    "bin/**/*.js",
-    "lib/*"
+    "bin/**/*.mjs",
+    "dist/*"
   ],
   "dependencies": {
     "@graphql-tools/graphql-file-loader": "^7.5.17",
     "@graphql-tools/load": "^7.8.14",
+    "@mui/material": "^7.3.7",
+    "@mui/x-data-grid": "^7.29.8",
     "change-case": "^4.1.2",
     "commander": "^9.5.0",
     "glob": "^11.1.0",
     "graphql": "^16.11.0",
+    "jiti": "^2.6.1",
     "object-path": "^0.11.8",
     "pluralize": "^8.0.0",
-    "ts-node": "^10.9.2"
+    "typescript": "5.9.3",
+    "@comet/admin": "9.0.0-beta.0",
+    "@comet/admin-icons": "9.0.0-beta.0",
+    "@comet/cms-admin": "9.0.0-beta.0"
   },
   "devDependencies": {
     "@apollo/client": "^3.14.0",
-    "@mui/material": "^7.3.7",
-    "@mui/x-data-grid": "^7.29.12",
     "@types/node": "^24.10.9",
     "@types/object-path": "^0.11.4",
     "@types/pluralize": "^0.0.33",
-    "@types/react": "^18.3.27",
+    "@types/react": "^19.2.10",
+    "@types/react-dom": "^19.2.3",
     "eslint": "^9.39.2",
     "final-form": "^4.20.10",
     "npm-run-all2": "^8.0.4",
     "prettier": "^3.6.2",
-    "react": "^18.3.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "react-intl": "^7.1.11",
-    "rimraf": "^6.1.2",
-    "typescript": "^5.9.3",
+    "tsdown": "0.20.0-beta.4",
     "vitest": "^4.0.16",
-    "@comet/admin": "8.17.1",
-    "@comet/admin-icons": "8.17.1",
-    "@comet/cms-admin": "8.17.1",
-    "@comet/eslint-config": "8.17.1"
+    "@comet/eslint-config": "9.0.0-beta.0"
+  },
+  "peerDependencies": {
+    "@apollo/client": "^3.7.0",
+    "final-form": "^4.0.0",
+    "react-intl": "^5.0.0 || ^6.0.0 || ^7.0.0"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -59,9 +70,8 @@
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "build": "pnpm run clean && tsc -p tsconfig.build.json",
-    "clean": "rimraf lib",
-    "dev": "tsc --watch --preserveWatchOutput -p tsconfig.build.json",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "lint": "run-p lint:prettier lint:eslint lint:tsc",
     "lint:ci": "pnpm run lint",
     "lint:eslint": "eslint --max-warnings 0 src/ **/*.json --no-warn-ignored",

package/bin/admin-generator.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-require("ts-node").register({
-    require: ["tsconfig-paths/register"],
-    transpileOnly: true,
-});
-
-require("../lib/adminGenerator");

package/lib/adminGenerator.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/adminGenerator.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const generate_command_1 = require("./commands/generate/generate-command");
-const program = new commander_1.Command();
-program.addCommand(generate_command_1.generateCommand);
-program.addHelpText("beforeAll", `⚠️️️⚠️️️⚠️️️  Admin Generator is still experimental and in beta phase. ⚠️️️⚠️️️⚠️️️ \n\n`);
-program.parse();

package/lib/commands/generate/config/parseConfig.d.ts

@@ -1 +0,0 @@
-export declare function parseConfig(file: string): Promise<any>;

package/lib/commands/generate/config/parseConfig.js

@@ -1,72 +0,0 @@
-"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;
-    };
-})();
-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.parseConfig = parseConfig;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const transformConfig_1 = require("./transformConfig");
-function parseConfig(file) {
-    return __awaiter(this, void 0, void 0, function* () {
-        //1. parse config file using TypeScript Complier Api and transform it (replace imports and functions that can't be executed)
-        const transformedConfig = (0, transformConfig_1.transformConfigFile)(file, yield fs_1.promises.readFile(file, "utf-8"));
-        //2. save modified config file to temp file
-        const tempFileName = `${(0, path_1.dirname)(file)}/.temp-${(0, path_1.basename)(file)}`;
-        yield fs_1.promises.writeFile(tempFileName, transformedConfig, "utf-8");
-        //3. import (=execute) temp modified config file
-        let executedConfig;
-        try {
-            const configFile = yield Promise.resolve(`${tempFileName.replace(/\.tsx?$/, "")}`).then(s => __importStar(require(s)));
-            if (!configFile.default) {
-                throw new Error(`No default export found in ${file}`);
-            }
-            executedConfig = configFile.default;
-        }
-        catch (e) {
-            console.error(e);
-            throw new Error(`Error executing config file ${file}: ${e}`);
-        }
-        yield fs_1.promises.rm(tempFileName);
-        return executedConfig;
-    });
-}

package/lib/commands/generate/config/transformConfig.d.ts

@@ -1,7 +0,0 @@
-import * as ts from "typescript";
-export declare function transformConfigFile(fileName: string, sourceText: string): string;
-export declare function collectImports(rootNode: ts.Node): Map<string, {
-    name: string;
-    import: string;
-    defaultImport?: boolean;
-}>;

package/lib/commands/generate/config/transformConfig.js

@@ -1,264 +0,0 @@
-"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.transformConfigFile = transformConfigFile;
-exports.collectImports = collectImports;
-const ts = __importStar(require("typescript"));
-const supportedImportPaths = [
-    "[type=grid].columns.filterOperators",
-    "[type=grid].columns.block",
-    "[type=grid].columns.component",
-    // TODO implement in generator "[type=grid].columns.renderCell",
-    //support in up to 5 levels of nested fields (eg. fieldSet)
-    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`),
-    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.block`),
-    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.component`),
-];
-const supportedInlineCodePaths = [
-    // TODO implement in generator "[type=grid].columns.filterOperators",
-    "[type=grid].columns.renderCell",
-    //support in up to 5 levels of nested fields (eg. fieldSet)
-    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`),
-];
-// transform the config file to replace all imports and inline code with a { code, imports } object
-// this is needed to be able to execute the config file in a node environment
-function transformConfigFile(fileName, sourceText) {
-    const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.ES2024, // language version
-    true);
-    const importedIdentifiers = collectImports(sourceFile);
-    function configTransformer() {
-        return (context) => {
-            const visit = (node, path) => {
-                if (ts.isCallExpression(node)) {
-                    if (node.expression.getText() === "injectFormVariables") {
-                        if (!path.startsWith("[type=form].fields")) {
-                            throw new Error(`injectFormVariables can only be used in form field definitions: ${path}`);
-                        }
-                        if (node.arguments.length !== 1) {
-                            throw new Error(`injectFormVariables expects exactly one argument`);
-                        }
-                        const injectFormVariablesArg = node.arguments[0];
-                        if (!ts.isArrowFunction(injectFormVariablesArg)) {
-                            throw new Error(`injectFormVariables expects an arrow function as its argument`);
-                        }
-                        node = injectFormVariablesArg.body;
-                    }
-                }
-                if (ts.isArrowFunction(node)) {
-                    if (supportedInlineCodePaths.includes(path)) {
-                        let code = node.getText();
-                        if (code.endsWith(","))
-                            code = code.slice(0, -1); // for some unknown reason node can contain the trailing comma
-                        const imports = findUsedImports(node.body, importedIdentifiers); //find all imports used in the function body
-                        // replace inline code with { code, imports } object
-                        return ts.factory.createObjectLiteralExpression([
-                            ts.factory.createPropertyAssignment("code", ts.factory.createStringLiteral(code)),
-                            ts.factory.createPropertyAssignment("imports", ts.factory.createArrayLiteralExpression(imports.map((imprt) => {
-                                return ts.factory.createObjectLiteralExpression([
-                                    ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(imprt.name)),
-                                    ts.factory.createPropertyAssignment("import", ts.factory.createStringLiteral(imprt.import)),
-                                    ...(imprt.defaultImport
-                                        ? [ts.factory.createPropertyAssignment("defaultImport", ts.factory.createTrue())]
-                                        : []),
-                                ]);
-                            }))),
-                        ], true);
-                    }
-                    else {
-                        throw new Error(`Inline Function is not allowed here and calling the function is not supported: ${path}`);
-                    }
-                }
-                else if (ts.isIdentifier(node)) {
-                    const imported = importedIdentifiers.get(node.text);
-                    if (imported) {
-                        if (supportedImportPaths.includes(path)) {
-                            // replace imported identifier with { name, import } object
-                            return ts.factory.createObjectLiteralExpression([
-                                ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(node.text)),
-                                ts.factory.createPropertyAssignment("import", ts.factory.createStringLiteral(imported.import)),
-                            ], true);
-                        }
-                    }
-                }
-                const transformKinds = [
-                    ts.SyntaxKind.Identifier,
-                    ts.SyntaxKind.ArrayLiteralExpression,
-                    ts.SyntaxKind.ObjectLiteralExpression,
-                    ts.SyntaxKind.TaggedTemplateExpression,
-                    ts.SyntaxKind.SpreadElement,
-                    ts.SyntaxKind.PropertyAssignment,
-                    ts.SyntaxKind.ShorthandPropertyAssignment,
-                ];
-                if (!transformKinds.includes(node.kind)) {
-                    // if the node is not one of the transformKinds, stop transformation at this level return it as is
-                    return node;
-                }
-                let newPath = path;
-                if (path == "") {
-                    // first entry of path is the type, then property names (. separated) are added
-                    if (ts.isObjectLiteralExpression(node)) {
-                        const typeProperty = getTypePropertyFromObjectLiteral(node);
-                        newPath = typeProperty ? `[type=${typeProperty}]` : "";
-                    }
-                }
-                else {
-                    if (ts.isPropertyAssignment(node)) {
-                        newPath = `${path}.${node.name.getText()}`;
-                    }
-                }
-                return ts.visitEachChild(node, (child) => {
-                    return visit(child, newPath);
-                }, context);
-            };
-            return (node) => ts.visitNode(node, (child) => visit(child, ""));
-        };
-    }
-    const configNode = findConfigNode(sourceFile);
-    const transformedConfigNode = ts.transform(configNode, [configTransformer()]).transformed[0];
-    const updatedSource = ts.transform(sourceFile, [
-        (context) => {
-            const visitor = (node) => {
-                if (node === configNode)
-                    return transformedConfigNode;
-                return ts.visitEachChild(node, visitor, context);
-            };
-            return (node) => ts.visitNode(node, visitor);
-        },
-    ]).transformed[0];
-    const printer = ts.createPrinter();
-    return printer.printFile(updatedSource);
-}
-// finds the config node in the source file (=default export, might be wrapped in defineConfig or uses satisfies)
-function findConfigNode(sourceFile) {
-    let ret;
-    sourceFile.forEachChild((node) => {
-        if (ts.isExportAssignment(node)) {
-            const exportedNode = node.expression;
-            if (ts.isCallExpression(exportedNode) && exportedNode.expression.getText() == "defineConfig") {
-                //export default defineConfig<Foo>({ ... });
-                const args = exportedNode.arguments;
-                if (args.length != 1) {
-                    throw new Error(`Expected exactly one argument for defineConfig`);
-                }
-                ret = args[0];
-                return false;
-            }
-            else if (ts.isSatisfiesExpression(exportedNode)) {
-                //export default { ... } satisfies GeneratorConfig<Foo>;
-                if (ts.isObjectLiteralExpression(exportedNode.expression)) {
-                    ret = exportedNode.expression;
-                    return false;
-                }
-            }
-            else if (ts.isObjectLiteralExpression(exportedNode)) {
-                //export default { ... };
-                ret = exportedNode;
-                return false;
-            }
-        }
-    });
-    if (!ret) {
-        throw new Error(`No default export found, please export the GeneratorConfig as default, preferrable using defineConfig helper.`);
-    }
-    return ret;
-}
-// simple helper that extracts the value of the type property from a object literal ({ type: "grid" } returns "grid")
-function getTypePropertyFromObjectLiteral(node) {
-    for (const property of node.properties) {
-        if (ts.isPropertyAssignment(property)) {
-            if (property.name.getText() == "type") {
-                const propertyAssignmentInitializer = property.initializer;
-                if (ts.isStringLiteral(propertyAssignmentInitializer)) {
-                    return propertyAssignmentInitializer.text;
-                }
-            }
-        }
-    }
-    return null;
-}
-// visits ast and collects all imports statements in the source file
-function collectImports(rootNode) {
-    const importedIdentifiers = new Map();
-    function visit(node) {
-        if (ts.isImportDeclaration(node) && node.importClause) {
-            const moduleSpecifier = node.moduleSpecifier.text;
-            if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
-                //named import
-                for (const element of node.importClause.namedBindings.elements) {
-                    const localName = element.name.text;
-                    const originalName = element.propertyName ? element.propertyName.text : localName;
-                    importedIdentifiers.set(localName, {
-                        name: originalName,
-                        import: moduleSpecifier,
-                    });
-                }
-            }
-            else if (node.importClause.name && ts.isIdentifier(node.importClause.name)) {
-                //default import
-                const localName = node.importClause.name.text;
-                importedIdentifiers.set(localName, {
-                    defaultImport: true,
-                    name: localName,
-                    import: moduleSpecifier,
-                });
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(rootNode);
-    return importedIdentifiers;
-}
-// visits ast and collects all identifiers that are an import
-function findUsedImports(rootNode, importedIdentifiers) {
-    const imports = [];
-    const usedNames = new Set();
-    // Collect all identifiers used in the rootNode
-    function collectUsedIdentifiers(node) {
-        if (ts.isIdentifier(node)) {
-            usedNames.add(node.text);
-        }
-        ts.forEachChild(node, collectUsedIdentifiers);
-    }
-    collectUsedIdentifiers(rootNode);
-    // Match used identifiers to imported ones
-    // NOTE: this is not 100% correct as it doesn't recognize cases where a import is overwritten by a local variable. But it is fast.
-    for (const name of usedNames) {
-        const imported = importedIdentifiers.get(name);
-        if (imported) {
-            imports.push(imported);
-        }
-    }
-    return imports;
-}