@comet/admin-generator 8.0.0-beta.4 → 8.0.0-beta.5

package/bin/admin-generator.js

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

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

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

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

@@ -0,0 +1,72 @@
+"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

@@ -0,0 +1 @@
+export declare function transformConfigFile(fileName: string, sourceText: string): string;

package/lib/commands/generate/config/transformConfig.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.transformConfigFile = transformConfigFile;
+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.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)),
+                                ]);
+                            }))),
+                        ], 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);
+                        }
+                        else {
+                            throw new Error(`Following the import is not supported: ${path} ${node.text}`);
+                        }
+                    }
+                }
+                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 &&
+            node.importClause.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            const moduleSpecifier = node.moduleSpecifier.text;
+            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,
+                });
+            }
+        }
+        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;
+}

package/lib/commands/generate/generate-command.d.ts

@@ -106,15 +106,6 @@ export type FormConfig<T extends {
     createMutation?: string;
     fields: (FormFieldConfig<T> | FormLayoutConfig<T> | ComponentFormFieldConfig)[];
 };
-type TabsConfig<T extends {
-    __typename?: string;
-}> = {
-    type: "tabs";
-    tabs: {
-        name: string;
-        content: GeneratorConfig<T>;
-    }[];
-};
 type BaseColumnConfig = Pick<GridColDef, "headerName" | "width" | "minWidth" | "maxWidth" | "flex" | "pinned" | "disableExport"> & {
     headerInfoTooltip?: string;
     visible?: ColumnVisibleOption;
@@ -130,6 +121,8 @@ export type GridColumnConfig<T extends GridValidRowModel> = ({
     renderCell?: (params: GridRenderCellParams<T, any, any>) => JSX.Element;
 } | {
     type: "number";
+    currency?: string;
+    decimals?: number;
     renderCell?: (params: GridRenderCellParams<T, any, any>) => JSX.Element;
 } | {
     type: "boolean";
@@ -193,10 +186,14 @@ export type GridConfig<T extends {
     newEntryText?: string;
     rowActionProp?: boolean;
     selectionProps?: "multiSelect" | "singleSelect";
+    rowReordering?: {
+        enabled: boolean;
+        dragPreviewField?: UsableFields<T>;
+    };
 };
 export type GeneratorConfig<T extends {
     __typename?: string;
-}> = FormConfig<T> | GridConfig<T> | TabsConfig<T>;
+}> = FormConfig<T> | GridConfig<T>;
 export declare function defineConfig<T extends {
     __typename?: string;
 }>(config: GeneratorConfig<T>): GeneratorConfig<T>;

package/lib/commands/generate/generate-command.js

@@ -20,9 +20,9 @@ const fs_1 = require("fs");
 const glob_1 = require("glob");
 const graphql_1 = require("graphql");
 const path_1 = require("path");
+const parseConfig_1 = require("./config/parseConfig");
 const generateForm_1 = require("./generateForm/generateForm");
 const generateGrid_1 = require("./generateGrid/generateGrid");
-const tsMorphHelper_1 = require("./utils/tsMorphHelper");
 const writeGenerated_1 = require("./utils/writeGenerated");
 function isFormFieldConfig(arg) {
     return !isFormLayoutConfig(arg);
@@ -50,13 +50,12 @@ function runGenerate() {
             const targetDirectory = `${(0, path_1.dirname)(file)}/generated`;
             const baseOutputFilename = (0, path_1.basename)(file).replace(/\.cometGen\.tsx?$/, "");
             console.log(`generating ${file}`);
-            const config = (0, tsMorphHelper_1.configFromSourceFile)((0, tsMorphHelper_1.morphTsSource)(file));
+            const config = yield (0, parseConfig_1.parseConfig)(file);
+            const codeOuputFilename = `${targetDirectory}/${(0, path_1.basename)(file.replace(/\.cometGen\.tsx?$/, ""))}.tsx`;
+            yield fs_1.promises.rm(codeOuputFilename, { force: true });
             const exportName = (_a = file.match(/([^/]+)\.cometGen\.tsx?$/)) === null || _a === void 0 ? void 0 : _a[1];
             if (!exportName)
                 throw new Error("Can not determine exportName");
-            //const configs = await import(`${process.cwd()}/${file.replace(/\.ts$/, "")}`);
-            const codeOuputFilename = `${targetDirectory}/${(0, path_1.basename)(file.replace(/\.cometGen\.tsx?$/, ""))}.tsx`;
-            yield fs_1.promises.rm(codeOuputFilename, { force: true });
             let generated;
             if (config.type == "form") {
                 generated = (0, generateForm_1.generateForm)({ exportName, gqlIntrospection, baseOutputFilename, targetDirectory }, config);
@@ -65,7 +64,7 @@ function runGenerate() {
                 generated = (0, generateGrid_1.generateGrid)({ exportName, gqlIntrospection, baseOutputFilename, targetDirectory }, config);
             }
             else {
-                throw new Error(`Unknown config type: ${config.type}`);
+                throw new Error(`Unknown config type`);
             }
             outputCode += generated.code;
             for (const queryName in generated.gqlDocuments) {
@@ -83,6 +82,7 @@ function runGenerate() {
             `;
                 yield (0, writeGenerated_1.writeGenerated)(gqlDocumentsOuputFilename, gqlDocumentsOutputCode);
             }
+            console.log("");
         }
     });
 }

package/lib/commands/generate/generateForm/generateForm.js

@@ -48,7 +48,43 @@ config) {
     const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
     const formFragmentName = (_a = config.fragmentName) !== null && _a !== void 0 ? _a : `${gqlType}Form`;
     const gqlDocuments = {};
-    const imports = [];
+    const imports = [
+        { name: "FormattedMessage", importPath: "react-intl" },
+        { name: "useApolloClient", importPath: "@apollo/client" },
+        { name: "useQuery", importPath: "@apollo/client" },
+        { name: "gql", importPath: "@apollo/client" },
+        { name: "AsyncSelectField", importPath: "@comet/admin" },
+        { name: "CheckboxField", importPath: "@comet/admin" },
+        { name: "Field", importPath: "@comet/admin" },
+        { name: "filterByFragment", importPath: "@comet/admin" },
+        { name: "FinalForm", importPath: "@comet/admin" },
+        { name: "FinalFormInput", importPath: "@comet/admin" },
+        { name: "FinalFormRangeInput", importPath: "@comet/admin" },
+        { name: "FinalFormSelect", importPath: "@comet/admin" },
+        { name: "FinalFormSubmitEvent", importPath: "@comet/admin" },
+        { name: "Loading", importPath: "@comet/admin" },
+        { name: "NumberField", importPath: "@comet/admin" },
+        { name: "RadioGroupField", importPath: "@comet/admin" },
+        { name: "TextAreaField", importPath: "@comet/admin" },
+        { name: "TextField", importPath: "@comet/admin" },
+        { name: "useFormApiRef", importPath: "@comet/admin" },
+        { name: "useStackSwitchApi", importPath: "@comet/admin" },
+        { name: "ArrowLeft", importPath: "@comet/admin-icons" },
+        { name: "Lock", importPath: "@comet/admin-icons" },
+        { name: "DateTimeField", importPath: "@comet/admin-date-time" },
+        { name: "FinalFormDatePicker", importPath: "@comet/admin-date-time" },
+        { name: "BlockState", importPath: "@comet/cms-admin" },
+        { name: "createFinalFormBlock", importPath: "@comet/cms-admin" },
+        { name: "queryUpdatedAt", importPath: "@comet/cms-admin" },
+        { name: "resolveHasSaveConflict", importPath: "@comet/cms-admin" },
+        { name: "useFormSaveConflict", importPath: "@comet/cms-admin" },
+        { name: "FileUploadField", importPath: "@comet/cms-admin" },
+        { name: "IconButton", importPath: "@mui/material" },
+        { name: "MenuItem", importPath: "@mui/material" },
+        { name: "InputAdornment", importPath: "@mui/material" },
+        { name: "FormApi", importPath: "final-form" },
+        { name: "useMemo", importPath: "react" },
+    ];
     const props = [];
     const mode = (_b = config.mode) !== null && _b !== void 0 ? _b : "all";
     const editMode = mode === "edit" || mode == "all";
@@ -219,10 +255,12 @@ config) {
             name: `GQL${documentName}${type[0].toUpperCase() + type.substring(1)}`,
             importPath: `./${baseOutputFilename}.gql.generated`,
         });
-        imports.push({
-            name: `GQL${documentName}${type[0].toUpperCase() + type.substring(1)}Variables`,
-            importPath: `./${baseOutputFilename}.gql.generated`,
-        });
+        if (type !== "fragment") {
+            imports.push({
+                name: `GQL${documentName}${type[0].toUpperCase() + type.substring(1)}Variables`,
+                importPath: `./${baseOutputFilename}.gql.generated`,
+            });
+        }
     }
     const finalFormSubscription = Object.keys((_e = (_d = generatedFields.finalFormConfig) === null || _d === void 0 ? void 0 : _d.subscription) !== null && _e !== void 0 ? _e : {});
     const finalFormRenderProps = Object.keys((_g = (_f = generatedFields.finalFormConfig) === null || _f === void 0 ? void 0 : _f.renderProps) !== null && _g !== void 0 ? _g : {});
@@ -248,34 +286,10 @@ config) {
         }`;
         filterByFragmentType = `${formFragmentName}Fragment`;
     }
-    const code = `import { useApolloClient, useQuery, gql } from "@apollo/client";
-    import {
-        AsyncSelectField,
-        CheckboxField,
-        Field,
-        filterByFragment,
-        FinalForm,
-        FinalFormInput,
-        FinalFormRangeInput,
-        FinalFormSelect,
-        FinalFormSubmitEvent,
-        Loading,
-        NumberField,
-        RadioGroupField,
-        TextAreaField,
-        TextField,
-        useFormApiRef,
-        useStackSwitchApi,
-    } from "@comet/admin";
-    import { ArrowLeft, Lock } from "@comet/admin-icons";
-    import { DateTimeField, FinalFormDatePicker } from "@comet/admin-date-time";
-    import { BlockState, createFinalFormBlock, queryUpdatedAt, resolveHasSaveConflict, useFormSaveConflict, FileUploadField } from "@comet/cms-admin";
-    import { FormControlLabel, IconButton, MenuItem, InputAdornment } from "@mui/material";
-    import { FormApi } from "final-form";
-    import isEqual from "lodash.isequal";
-    import { useMemo } from "react";
-    import { FormattedMessage } from "react-intl";
+    const code = `
     ${(0, generateImportsCode_1.generateImportsCode)(imports)}
+    import isEqual from "lodash.isequal";
+
     ${rootBlockFields.length > 0
         ? `const rootBlocks = {
                 ${rootBlockFields.map((field) => `${String(field.name)}: ${field.block.name}`)}
@@ -284,11 +298,11 @@ config) {
 
     ${customFilterByFragment}
 
-    type FormValues = ${formValuesConfig.filter((config) => !!config.omitFromFragmentType).length > 0
-        ? `Omit<${filterByFragmentType}, ${formValuesConfig
-            .filter((config) => !!config.omitFromFragmentType)
-            .map((config) => `"${config.omitFromFragmentType}"`)
-            .join(" | ")}>`
+    type FormValues = ${formValuesConfig.filter((config) => !!config.omitFromFragmentType).length > 0 || rootBlockFields.length > 0
+        ? `Omit<${filterByFragmentType}, ${[
+            ...(rootBlockFields.length > 0 ? ["keyof typeof rootBlocks"] : []),
+            ...formValuesConfig.filter((config) => !!config.omitFromFragmentType).map((config) => `"${config.omitFromFragmentType}"`),
+        ].join(" | ")}>`
         : `${filterByFragmentType}`} ${formValuesConfig.filter((config) => !!config.typeCode).length > 0
         ? `& {
                 ${formValuesConfig

package/lib/commands/generate/generateForm/generateFormField.js

@@ -140,6 +140,7 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
     let formValueToGqlInputCode = "";
     let formFragmentField = name;
     if (config.type == "text") {
+        const required = config.required !== undefined ? config.required : false; // don't use inferred from gql here, non-nullable textinput allows empty string
         const TextInputComponent = config.multiline ? "TextAreaField" : "TextField";
         code = `
         <${TextInputComponent}

package/lib/commands/generate/generateGrid/generateGrid.js

@@ -115,7 +115,7 @@ const getValueOptionsLabelData = (messageId, label) => {
     };
 };
 function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection, }, config) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const gqlType = config.gqlType;
     const gqlTypePlural = (0, pluralize_1.plural)(gqlType);
     //const title = config.title ?? camelCaseToHumanReadable(gqlType);
@@ -123,8 +123,58 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
     const instanceGqlTypePlural = gqlTypePlural[0].toLowerCase() + gqlTypePlural.substring(1);
     const gridQuery = config.query ? config.query : instanceGqlType != instanceGqlTypePlural ? instanceGqlTypePlural : `${instanceGqlTypePlural}List`;
     const gqlDocuments = {};
-    const imports = [];
-    const iconsToImport = ["Add", "Edit"];
+    const imports = [
+        { name: "FormattedMessage", importPath: "react-intl" },
+        { name: "FormattedNumber", importPath: "react-intl" },
+        { name: "useIntl", importPath: "react-intl" },
+        { name: "ReactNode", importPath: "react" },
+        { name: "gql", importPath: "@apollo/client" },
+        { name: "useApolloClient", importPath: "@apollo/client" },
+        { name: "useQuery", importPath: "@apollo/client" },
+        { name: "Button", importPath: "@comet/admin" },
+        { name: "CrudContextMenu", importPath: "@comet/admin" },
+        { name: "CrudMoreActionsMenu", importPath: "@comet/admin" },
+        { name: "DataGridToolbar", importPath: "@comet/admin" },
+        { name: "ExportApi", importPath: "@comet/admin" },
+        { name: "filterByFragment", importPath: "@comet/admin" },
+        { name: "GridFilterButton", importPath: "@comet/admin" },
+        { name: "GridCellContent", importPath: "@comet/admin" },
+        { name: "GridColDef", importPath: "@comet/admin" },
+        { name: "dataGridDateTimeColumn", importPath: "@comet/admin" },
+        { name: "dataGridDateColumn", importPath: "@comet/admin" },
+        { name: "renderStaticSelectCell", importPath: "@comet/admin" },
+        { name: "messages", importPath: "@comet/admin" },
+        { name: "muiGridFilterToGql", importPath: "@comet/admin" },
+        { name: "muiGridSortToGql", importPath: "@comet/admin" },
+        { name: "StackLink", importPath: "@comet/admin" },
+        { name: "FillSpace", importPath: "@comet/admin" },
+        { name: "Tooltip", importPath: "@comet/admin" },
+        { name: "useBufferedRowCount", importPath: "@comet/admin" },
+        { name: "useDataGridExcelExport", importPath: "@comet/admin" },
+        { name: "useDataGridRemote", importPath: "@comet/admin" },
+        { name: "usePersistentColumnState", importPath: "@comet/admin" },
+        { name: "BlockPreviewContent", importPath: "@comet/cms-admin" },
+        { name: "useContentScope", importPath: "@comet/cms-admin" },
+        { name: "Alert", importPath: "@mui/material" },
+        { name: "Box", importPath: "@mui/material" },
+        { name: "IconButton", importPath: "@mui/material" },
+        { name: "Typography", importPath: "@mui/material" },
+        { name: "useTheme", importPath: "@mui/material" },
+        { name: "Menu", importPath: "@mui/material" },
+        { name: "MenuItem", importPath: "@mui/material" },
+        { name: "ListItemIcon", importPath: "@mui/material" },
+        { name: "ListItemText", importPath: "@mui/material" },
+        { name: "CircularProgress", importPath: "@mui/material" },
+        { name: "DataGridPro", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridLogicOperator", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridRenderCellParams", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridSlotsComponent", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridToolbarProps", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridColumnHeaderTitle", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridToolbarQuickFilter", importPath: "@mui/x-data-grid-pro" },
+        { name: "GridRowOrderChangeParams", importPath: "@mui/x-data-grid-pro" },
+    ];
+    const iconsToImport = ["Add", "Edit", "Info", "Excel"];
     const props = [];
     const fieldList = (0, generateGqlFieldList_1.generateGqlFieldList)({
         columns: config.columns.filter((column) => {
@@ -161,12 +211,29 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
     });
     const gridQueryType = (0, findQueryType_1.findQueryTypeOrThrow)(gridQuery, gqlIntrospection);
     const createMutationType = (0, findMutationType_1.findMutationType)(`create${gqlType}`, gqlIntrospection);
+    const updateMutationType = (0, findMutationType_1.findMutationType)(`update${gqlType}`, gqlIntrospection);
     const hasDeleteMutation = !!(0, findMutationType_1.findMutationType)(`delete${gqlType}`, gqlIntrospection);
     const hasCreateMutation = !!createMutationType;
+    const hasUpdateMutation = !!updateMutationType;
     const allowCopyPaste = (typeof config.copyPaste === "undefined" || config.copyPaste === true) && !config.readOnly && hasCreateMutation;
     const allowAdding = (typeof config.add === "undefined" || config.add === true) && !config.readOnly;
     const allowEditing = (typeof config.edit === "undefined" || config.edit === true) && !config.readOnly;
     const allowDeleting = (typeof config.delete === "undefined" || config.delete === true) && !config.readOnly && hasDeleteMutation;
+    const allowRowReordering = typeof ((_a = config.rowReordering) === null || _a === void 0 ? void 0 : _a.enabled) !== "undefined" && ((_b = config.rowReordering) === null || _b === void 0 ? void 0 : _b.enabled) && hasUpdateMutation;
+    const updateInputArg = updateMutationType === null || updateMutationType === void 0 ? void 0 : updateMutationType.args.find((arg) => arg.name === "input");
+    if (allowRowReordering && updateInputArg) {
+        const inputType = (0, findInputObjectType_1.findInputObjectType)(updateInputArg, gqlIntrospection);
+        if (!inputType)
+            throw new Error("Can't find update input type");
+        if (!((_c = inputType.inputFields) === null || _c === void 0 ? void 0 : _c.find((field) => field.name === "position"))) {
+            throw new Error("Position field is needed when using 'rowReordering'");
+        }
+    }
+    const hasRowReorderingOnDragField = allowRowReordering && typeof ((_d = config.rowReordering) === null || _d === void 0 ? void 0 : _d.dragPreviewField) !== "undefined";
+    if (hasRowReorderingOnDragField &&
+        !config.columns.find((column) => { var _a; return column.type !== "actions" && (column === null || column === void 0 ? void 0 : column.name) === ((_a = config.rowReordering) === null || _a === void 0 ? void 0 : _a.dragPreviewField); })) {
+        throw new Error(`rowReorderingOnDragField '${(_e = config.rowReordering) === null || _e === void 0 ? void 0 : _e.dragPreviewField}' must exist in columns`);
+    }
     const forwardRowAction = allowEditing && config.rowActionProp;
     const showActionsColumn = allowCopyPaste || allowEditing || allowDeleting;
     const showCrudContextMenuInActionsColumn = allowCopyPaste || allowDeleting;
@@ -175,9 +242,9 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
     const { imports: forwardedGqlArgsImports, props: forwardedGqlArgsProps, gqlArgs, } = (0, getForwardedGqlArgs_1.getForwardedGqlArgs)([gridQueryType, ...(createMutationType ? [createMutationType] : [])]);
     imports.push(...forwardedGqlArgsImports);
     props.push(...forwardedGqlArgsProps);
-    const renderToolbar = (_a = config.toolbar) !== null && _a !== void 0 ? _a : true;
+    const renderToolbar = (_f = config.toolbar) !== null && _f !== void 0 ? _f : true;
     const filterArg = gridQueryType.args.find((arg) => arg.name === "filter");
-    const hasFilter = !!filterArg && renderToolbar;
+    const hasFilter = !!filterArg && renderToolbar && !allowRowReordering;
     let hasFilterProp = false;
     let filterFields = [];
     if (filterArg) {
@@ -223,8 +290,11 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         if (!sortInputEnum)
             throw new Error("Can't find sortInputEnum");
         sortFields = sortInputEnum.enumValues.map((v) => v.name.replace(/_/g, "."));
+        if (allowRowReordering && !sortFields.includes("position")) {
+            throw new Error("Sort argument must include 'position' field for row reordering");
+        }
     }
-    const hasSearch = gridQueryType.args.some((arg) => arg.name === "search");
+    const hasSearch = gridQueryType.args.some((arg) => arg.name === "search") && !allowRowReordering;
     const hasScope = gridQueryType.args.some((arg) => arg.name === "scope");
     const schemaEntity = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
     if (!schemaEntity)
@@ -247,7 +317,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         return true;
     });
     const actionsColumnConfig = config.columns.find((column) => column.type === "actions");
-    const _c = actionsColumnConfig !== null && actionsColumnConfig !== void 0 ? actionsColumnConfig : {}, { component: actionsColumnComponent, type: actionsColumnType, headerName: actionsColumnHeaderName, pinned: actionsColumnPinned = "right", width: actionsColumnWidth = defaultActionsColumnWidth, visible: actionsColumnVisible = undefined } = _c, restActionsColumnConfig = __rest(_c, ["component", "type", "headerName", "pinned", "width", "visible"]);
+    const _j = actionsColumnConfig !== null && actionsColumnConfig !== void 0 ? actionsColumnConfig : {}, { component: actionsColumnComponent, type: actionsColumnType, headerName: actionsColumnHeaderName, pinned: actionsColumnPinned = "right", width: actionsColumnWidth = defaultActionsColumnWidth, visible: actionsColumnVisible = undefined } = _j, restActionsColumnConfig = __rest(_j, ["component", "type", "headerName", "pinned", "width", "visible"]);
     if (actionsColumnComponent) {
         if (!(0, runtimeTypeGuards_1.isGeneratorConfigImport)(actionsColumnComponent)) {
             throw new Error("Unsupported actionsColumnComponent, only imports are supported");
@@ -281,6 +351,12 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         }
         else if (type == "number") {
             gridType = "number";
+            const defaultDecimals = column.currency ? 2 : 0;
+            const decimals = typeof column.decimals === "number" ? column.decimals : defaultDecimals;
+            const currencyProps = column.currency ? `style="currency" currency="${column.currency}"` : "";
+            renderCell = `({ value }) => {
+                return (typeof value === "number") ? <FormattedNumber value={value} ${currencyProps} minimumFractionDigits={${decimals}} maximumFractionDigits={${decimals}} /> : "";
+            }`;
         }
         else if (type == "boolean") {
             gridType = "boolean";
@@ -419,7 +495,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
             createMutationInputFields = inputType.inputFields.filter((field) => fieldsToLoad.some((gridColumnField) => gridColumnField.name == field.name));
         }
     }
-    const fragmentName = (_b = config.fragmentName) !== null && _b !== void 0 ? _b : `${gqlTypePlural}Form`;
+    const fragmentName = (_g = config.fragmentName) !== null && _g !== void 0 ? _g : `${gqlTypePlural}Form`;
     if (forwardRowAction) {
         props.push({
             name: "rowAction",
@@ -458,7 +534,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
             : ""}
               ${config.initialFilter
             ? `initialFilter:{ ${config.initialFilter.linkOperator
-                ? `linkOperator: GridLinkOperator.${config.initialFilter.linkOperator === "or" ? "Or" : "And"},`
+                ? `linkOperator: GridLogicOperator.${config.initialFilter.linkOperator === "or" ? "Or" : "And"},`
                 : ""}
                       items: [${config.initialFilter.items
                 .map((item) => {
@@ -469,47 +545,17 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
               ${config.queryParamsPrefix ? `queryParamsPrefix: "${config.queryParamsPrefix}",` : ""}
               }`
         : "";
-    const code = `import { gql, useApolloClient, useQuery } from "@apollo/client";
-    import {
-        Button,
-        CrudContextMenu,
-        CrudMoreActionsMenu,
-        DataGridToolbar,
-        ExportApi,
-        filterByFragment,
-        GridFilterButton,
-        GridCellContent,
-        GridColDef,
-        dataGridDateTimeColumn,
-        dataGridDateColumn,
-        renderStaticSelectCell,
-        messages,
-        muiGridFilterToGql,
-        muiGridSortToGql,
-        StackLink,
-        FillSpace,
-        Tooltip,
-        useBufferedRowCount,
-        useDataGridExcelExport,
-        useDataGridRemote,
-        usePersistentColumnState,
-    } from "@comet/admin";
-    import { Add as AddIcon, Edit, Info, MoreVertical, Excel } from "@comet/admin-icons";
-    import { BlockPreviewContent } from "@comet/cms-admin";
-    import { Alert, Box, IconButton, Typography, useTheme, Menu, MenuItem, ListItemIcon, ListItemText, CircularProgress } from "@mui/material";
-    import { DataGridPro, GridLinkOperator, GridRenderCellParams, GridSlotsComponent, GridToolbarProps, GridColumnHeaderTitle, GridToolbarQuickFilter } from "@mui/x-data-grid-pro";
-    import { useContentScope } from "@src/common/ContentScopeProvider";
-    import {
+    const code = `import {
         GQL${gqlTypePlural}GridQuery,
         GQL${gqlTypePlural}GridQueryVariables,
         GQL${fragmentName}Fragment,
         GQLCreate${gqlType}Mutation,
         GQLCreate${gqlType}MutationVariables,
+        GQLUpdate${gqlType}PositionMutation,
+        GQLUpdate${gqlType}PositionMutationVariables,
         GQLDelete${gqlType}Mutation,
         GQLDelete${gqlType}MutationVariables
     } from "./${baseOutputFilename}.generated";
-    import { ReactNode } from "react";
-    import { FormattedMessage, FormattedNumber, useIntl } from "react-intl";
     ${(0, generateImportsCode_1.generateImportsCode)(imports)}
 
     const ${instanceGqlTypePlural}Fragment = gql\`
@@ -545,6 +591,17 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         \${${instanceGqlTypePlural}Fragment}
     \`;
 
+    ${allowRowReordering
+        ? `const update${gqlType}PositionMutation = gql\`
+                mutation Update${gqlType}Position($id: ID!, $input: ${gqlType}UpdateInput!) {
+                    update${gqlType}(id: $id, input: $input) {
+                        id
+                        position
+                        updatedAt
+                    }
+                }
+            \`;`
+        : ""}
 
     ${allowDeleting
         ? `const delete${gqlType}Mutation = gql\`
@@ -600,6 +657,8 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         ${hasScope ? `const { scope } = useContentScope();` : ""}
         ${gridNeedsTheme ? `const theme = useTheme();` : ""}
 
+        ${generateHandleRowOrderChange(allowRowReordering, gqlType, instanceGqlTypePlural)}
+
         const columns: GridColDef<GQL${fragmentName}Fragment>[] = [
             ${gridColumnFields
         .map((column) => {
@@ -630,7 +689,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
                                         <Tooltip
                                             title={<FormattedMessage id="${instanceGqlType}.${column.name}.tooltip" defaultMessage="${column.headerInfoTooltip}" />}
                                         >
-                                            <Info sx={{ marginLeft: 1 }} />
+                                            <InfoIcon sx={{ marginLeft: 1 }} />
                                         </Tooltip>
                                     </>
                                 )`
@@ -639,8 +698,8 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
                 ? `intl.formatMessage({ id: "${instanceGqlType}.${column.name}", defaultMessage: "${column.headerName || (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(column.name)}" })`
                 : undefined,
             type: column.gridType ? `"${column.gridType}"` : undefined,
-            filterable: !column.filterOperators && !filterFields.includes(column.name) ? `false` : undefined,
-            sortable: !sortFields.includes(column.name) ? `false` : undefined,
+            filterable: (!column.filterOperators && !filterFields.includes(column.name)) || allowRowReordering ? `false` : undefined,
+            sortable: !sortFields.includes(column.name) || allowRowReordering ? `false` : undefined,
             valueGetter: column.valueGetter,
             valueFormatter: column.valueFormatter,
             valueOptions: column.valueOptions,
@@ -753,17 +812,20 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
                         : []
             : []),
         ...(hasSearch ? ["search: gqlSearch"] : []),
-        ...[
-            `offset: dataGridProps.paginationModel.page * dataGridProps.paginationModel.pageSize`,
-            `limit: dataGridProps.paginationModel.pageSize`,
-            `sort: muiGridSortToGql(dataGridProps.sortModel)`,
-        ],
+        ...(!allowRowReordering
+            ? [
+                `offset: dataGridProps.paginationModel.page * dataGridProps.paginationModel.pageSize`,
+                `limit: dataGridProps.paginationModel.pageSize`,
+                `sort: muiGridSortToGql(dataGridProps.sortModel)`,
+            ]
+            : // TODO: offset and limit should not be necessary for row reordering but not yet possible to disable in the api generator
+                [`offset: 0`, `limit: 100`, `sort: { field: "position", direction: "ASC" }`]),
     ].join(", ")}
             },
         });
         const rowCount = useBufferedRowCount(data?.${gridQuery}.totalCount);
         if (error) throw error;
-        const rows = data?.${gridQuery}.nodes ?? [];
+        const rows = ${!allowRowReordering ? `data?.${gridQuery}.nodes` : generateRowReorderingRows(gridQuery, fieldList, (_h = config.rowReordering) === null || _h === void 0 ? void 0 : _h.dragPreviewField)} ?? [];
 
         ${generateGridExportApi(config.excelExport, gqlTypePlural, gridQuery)}
 
@@ -779,6 +841,11 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
                                 toolbar: ${gridToolbarComponentName} as GridSlotsComponent["toolbar"],
                             }}
                             ${getDataGridSlotProps(gridToolbarComponentName, forwardToolbarAction, config.excelExport)}`
+        : ""}
+                ${allowRowReordering
+        ? `rowReordering
+                           onRowOrderChange={handleRowOrderChange}
+                           hideFooterPagination`
         : ""}
             />
         );
@@ -789,6 +856,14 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         gqlDocuments,
     };
 }
+const generateRowReorderingRows = (gridQuery, fieldList, dragPreviewField) => {
+    const fields = fieldList.split(" ");
+    const reorderField = dragPreviewField || fields.find((field) => field === "title" || field === "name") || "id";
+    return `data?.${gridQuery}.nodes.map((node) => ({
+        ...node,
+        __reorder__: node.${reorderField}
+    }))`;
+};
 const getDefaultActionsColumnWidth = (showCrudContextMenu, showEdit) => {
     let numberOfActions = 0;
     if (showCrudContextMenu) {
@@ -830,3 +905,16 @@ const generateGridExportApi = (excelExport, gqlTypePlural, gridQuery) => {
         },
     });`;
 };
+const generateHandleRowOrderChange = (allowRowReordering, gqlType, instanceGqlTypePlural) => {
+    if (!allowRowReordering) {
+        return "";
+    }
+    return `const handleRowOrderChange = async ({ row: { id }, targetIndex }: GridRowOrderChangeParams) => {
+        await client.mutate<GQLUpdate${gqlType}PositionMutation, GQLUpdate${gqlType}PositionMutationVariables>({
+            mutation: update${gqlType}PositionMutation,
+            variables: { id, input: { position: targetIndex + 1 } },
+            awaitRefetchQueries: true,
+            refetchQueries: [${instanceGqlTypePlural}Query]
+        });
+    };`;
+};

package/lib/commands/generate/generateGrid/generateGridToolbar.js

@@ -59,7 +59,7 @@ const renderToolbarActions = ({ forwardToolbarAction, addItemText, excelExport,
             ${excelExport
         ? `{
                         label: <FormattedMessage {...messages.downloadAsExcel} />,
-                        icon: exportApi.loading ? <CircularProgress size={20} /> : <Excel />,
+                        icon: exportApi.loading ? <CircularProgress size={20} /> : <ExcelIcon />,
                         onClick: () => exportApi.exportGrid(),
                         disabled: exportApi.loading,
                     }`

package/lib/commands/generate/utils/writeGenerated.js

@@ -46,39 +46,78 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeGenerated = writeGenerated;
-const chalk_1 = __importDefault(require("chalk"));
-const eslint_1 = require("eslint");
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
 function writeGenerated(filePath, contents) {
     return __awaiter(this, void 0, void 0, function* () {
         const header = `// This file has been generated by comet admin-generator.
     // You may choose to use this file as scaffold by moving this file out of generated folder and removing this comment.
     `;
         yield fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
-        const eslint = new eslint_1.ESLint({
-            cwd: process.cwd(),
-            fix: true,
+        const sourceFile = typescript_1.default.createSourceFile(filePath, header + contents, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TSX);
+        const result = typescript_1.default.transform(sourceFile, [removeUnusedImports()]);
+        const printer = typescript_1.default.createPrinter({
+            newLine: typescript_1.default.NewLineKind.LineFeed,
+            removeComments: false,
         });
-        // Write not linted generated code into file. This is necessary to avoid linting errors like: Parsing error: file/path/file.tsx was not found by the project service.
-        yield fs_1.promises.writeFile(filePath, header + contents);
-        const lintResult = yield eslint.lintText(header + contents, {
-            filePath,
-        });
-        if (lintResult[0].errorCount > 0 || lintResult[0].fatalErrorCount > 0) {
-            const errorMessage = lintResult[0].messages
-                .map((message) => {
-                return message.message;
-            })
-                .join(".");
-            console.error(chalk_1.default.red(`Linting error in ${filePath}: \n${errorMessage}`));
-        }
-        else if (lintResult[0].output != null) {
-            yield fs_1.promises.writeFile(filePath, lintResult[0].output);
-        }
-        else {
-            console.error(chalk_1.default.red("No output from linting"));
-        }
+        const prettyCode = printer.printFile(result.transformed[0]).replace(/gql `/g, "gql`");
+        yield fs_1.promises.writeFile(filePath, prettyCode);
         console.log(`generated ${filePath}`);
     });
 }
+// copy from @comet/api-generator
+function removeUnusedImports() {
+    return (context) => {
+        function visit(sourceFile) {
+            const usedIdentifiers = new Set();
+            // Step 1: Collect all used identifiers
+            function collectUsage(node) {
+                if (typescript_1.default.isIdentifier(node)) {
+                    usedIdentifiers.add(node.text);
+                }
+                else if (typescript_1.default.isImportDeclaration(node)) {
+                    // Skip import declarations (those identifiers are not usages)
+                    return;
+                }
+                typescript_1.default.forEachChild(node, collectUsage);
+            }
+            typescript_1.default.forEachChild(sourceFile, collectUsage);
+            // Step 2: Visit and update the import declarations
+            function visitor(node) {
+                if (typescript_1.default.isImportDeclaration(node) && node.importClause) {
+                    const { name, namedBindings } = node.importClause;
+                    const updatedBindings = [];
+                    if (name && usedIdentifiers.has(name.text)) {
+                        // default import is used
+                    }
+                    else if (name) {
+                        // default import is unused
+                        return undefined;
+                    }
+                    if (namedBindings && typescript_1.default.isNamedImports(namedBindings)) {
+                        for (const specifier of namedBindings.elements) {
+                            const importName = specifier.name.text;
+                            if (usedIdentifiers.has(importName)) {
+                                updatedBindings.push(specifier);
+                            }
+                        }
+                        if (updatedBindings.length === 0 && !name) {
+                            // nothing left in this import
+                            return undefined;
+                        }
+                        return typescript_1.default.factory.updateImportDeclaration(node, node.modifiers, typescript_1.default.factory.updateImportClause(node.importClause, node.importClause.isTypeOnly, name, updatedBindings.length > 0 ? typescript_1.default.factory.updateNamedImports(namedBindings, updatedBindings) : undefined), node.moduleSpecifier, node.assertClause);
+                    }
+                    if (!namedBindings && !name) {
+                        // empty import, probably a side-effect import
+                        return node;
+                    }
+                    return node;
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        }
+        return (sourceFile) => visit(sourceFile);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comet/admin-generator",
-  "version": "8.0.0-beta.4",
+  "version": "8.0.0-beta.5",
   "repository": {
     "directory": "packages/admin/admin-generator",
     "type": "git",
@@ -19,24 +19,22 @@
   "dependencies": {
     "@graphql-tools/graphql-file-loader": "^7.5.17",
     "@graphql-tools/load": "^7.8.14",
-    "chalk": "^5.4.1",
     "change-case": "^4.1.2",
     "commander": "^9.5.0",
     "glob": "^10.4.5",
     "graphql": "^16.10.0",
     "object-path": "^0.11.8",
     "pluralize": "^8.0.0",
-    "ts-morph": "^25.0.1",
     "ts-node": "^10.9.2"
   },
   "devDependencies": {
-    "@mui/material": "^7.0.0",
-    "@mui/x-data-grid": "^7.28.1",
+    "@mui/material": "^7.1.0",
+    "@mui/x-data-grid": "^7.29.4",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.14.0",
+    "@types/node": "^22.15.21",
     "@types/object-path": "^0.11.4",
     "@types/pluralize": "^0.0.33",
-    "@types/react": "^18.3.20",
+    "@types/react": "^18.3.22",
     "eslint": "^9.22.0",
     "final-form": "^4.20.10",
     "jest": "^29.7.0",
@@ -47,10 +45,10 @@
     "rimraf": "^6.0.1",
     "ts-jest": "^29.2.6",
     "typescript": "^5.7.3",
-    "@comet/admin": "8.0.0-beta.4",
-    "@comet/admin-icons": "8.0.0-beta.4",
-    "@comet/cms-admin": "8.0.0-beta.4",
-    "@comet/eslint-config": "8.0.0-beta.4"
+    "@comet/admin": "8.0.0-beta.5",
+    "@comet/admin-icons": "8.0.0-beta.5",
+    "@comet/cms-admin": "8.0.0-beta.5",
+    "@comet/eslint-config": "8.0.0-beta.5"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -67,7 +65,7 @@
     "lint:eslint": "eslint --max-warnings 0 src/ **/*.json --no-warn-ignored",
     "lint:prettier": "npx prettier --check './**/*.{js,json,md,yml,yaml}'",
     "lint:tsc": "tsc",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch"
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
   }
 }

package/lib/commands/generate/utils/tsMorphHelper.d.ts

@@ -1,4 +0,0 @@
-import { type SourceFile } from "ts-morph";
-import { type GeneratorConfig } from "../generate-command";
-export declare function morphTsSource(path: string): SourceFile;
-export declare function configFromSourceFile(sourceFile: SourceFile): GeneratorConfig<any>;

package/lib/commands/generate/utils/tsMorphHelper.js

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.morphTsSource = morphTsSource;
-exports.configFromSourceFile = configFromSourceFile;
-const ts_morph_1 = require("ts-morph");
-const project = new ts_morph_1.Project({
-    tsConfigFilePath: "tsconfig.json",
-    skipAddingFilesFromTsConfig: true,
-});
-function morphTsSource(path) {
-    let tsSource = project.getSourceFile(path);
-    if (!tsSource)
-        tsSource = project.addSourceFileAtPath(path);
-    return tsSource;
-}
-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`),
-];
-function configFromSourceFile(sourceFile) {
-    for (const [name, declarations] of Array.from(sourceFile.getExportedDeclarations().entries())) {
-        if (name == "default") {
-            if (declarations.length != 1) {
-                throw new Error(`Expected exactly one declaration for ${name}`);
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const config = exportedDeclarationToJson(declarations[0]);
-            //console.dir(config, { depth: 10 });
-            return config;
-        }
-        else {
-            //ignore this export
-        }
-    }
-    throw new Error(`No default export found, please export the GeneratorConfig as default, preferrable using defineConfig helper.`);
-}
-function findUsedImports(node) {
-    const imports = [];
-    node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier).forEach((identifier) => {
-        var _a;
-        for (const referencedSymbol of identifier.findReferences()) {
-            for (const reference of referencedSymbol.getReferences()) {
-                const referenceNode = reference.getNode();
-                const importDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration);
-                if (importDeclaration) {
-                    for (const namedImport of importDeclaration.getNamedImports()) {
-                        if (((_a = (namedImport.getAliasNode() || namedImport.getNameNode())) === null || _a === void 0 ? void 0 : _a.getText()) == referenceNode.getText()) {
-                            imports.push({
-                                name: namedImport.getNameNode().getText(),
-                                import: importDeclaration.getModuleSpecifierValue(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    });
-    return imports;
-}
-function getTypePropertyFromObjectLiteral(node) {
-    for (const property of node.getProperties()) {
-        if (property.getKind() == ts_morph_1.SyntaxKind.PropertyAssignment) {
-            const propertyAssignment = property;
-            if (propertyAssignment.getName() == "type") {
-                const propertyAssignmentInitializer = propertyAssignment.getInitializer();
-                if ((propertyAssignmentInitializer === null || propertyAssignmentInitializer === void 0 ? void 0 : propertyAssignmentInitializer.getKind()) == ts_morph_1.SyntaxKind.StringLiteral) {
-                    return propertyAssignmentInitializer.getLiteralValue();
-                }
-            }
-        }
-    }
-    return null;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function astNodeToJson(node, path) {
-    var _a;
-    if (node.getKind() == ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
-        if (path == "") {
-            // first entry of path is the type, then property names (. separated) are added
-            const typeProperty = getTypePropertyFromObjectLiteral(node);
-            path = typeProperty ? `[type=${typeProperty}]` : "";
-        }
-        const ret = {};
-        for (const property of node.getProperties()) {
-            if (property.getKind() == ts_morph_1.SyntaxKind.PropertyAssignment) {
-                const propertyAssignment = property;
-                const propertyAssignmentInitializer = propertyAssignment.getInitializer();
-                if (propertyAssignmentInitializer) {
-                    ret[propertyAssignment.getName()] = astNodeToJson(propertyAssignmentInitializer, `${path}.${propertyAssignment.getName()}`);
-                }
-                else {
-                    throw new Error(`Initializer is required for propertyAssignment '${propertyAssignment.getName()}'`);
-                }
-            }
-            else {
-                throw new Error(`Unsupported ObjectLiteralExpression property Kind ${property.getKindName()}`);
-            }
-        }
-        return ret;
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.StringLiteral) {
-        return node.getLiteralValue();
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.NumericLiteral) {
-        return node.getLiteralValue();
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.FalseKeyword) {
-        return false;
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.TrueKeyword) {
-        return true;
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.BinaryExpression) {
-        //what is this?
-        return node.getText();
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.ArrowFunction) {
-        if (supportedInlineCodePaths.includes(path)) {
-            const body = node.getBody();
-            return {
-                code: node.getText(),
-                imports: findUsedImports(body),
-            };
-        }
-        else {
-            throw new Error(`Inline Function is not allowed here and calling the function is not supported: ${path}`);
-        }
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
-        const ret = [];
-        for (const element of node.getElements()) {
-            ret.push(astNodeToJson(element, path));
-        }
-        return ret;
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.Identifier) {
-        for (const referencedSymbol of node.findReferences()) {
-            for (const reference of referencedSymbol.getReferences()) {
-                const referenceNode = reference.getNode();
-                const importDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration);
-                const variableDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.VariableDeclaration);
-                if (importDeclaration) {
-                    for (const namedImport of importDeclaration.getNamedImports()) {
-                        if (((_a = (namedImport.getAliasNode() || namedImport.getNameNode())) === null || _a === void 0 ? void 0 : _a.getText()) == referenceNode.getText()) {
-                            if (supportedImportPaths.includes(path)) {
-                                return {
-                                    name: namedImport.getNameNode().getText(),
-                                    import: importDeclaration.getModuleSpecifierValue(),
-                                };
-                            }
-                            else {
-                                throw new Error(`Following the import is not supported: ${path} ${namedImport.getText()}`);
-                            }
-                        }
-                    }
-                }
-                else if (variableDeclaration) {
-                    if (variableDeclaration.getName() == node.getText()) {
-                        const variableInitializer = variableDeclaration.getInitializer();
-                        if (variableInitializer) {
-                            return astNodeToJson(variableInitializer, path);
-                        }
-                        else {
-                            throw new Error(`Initializer is required for variableDeclaration '${variableDeclaration.getName()}'`);
-                        }
-                    }
-                }
-            }
-        }
-        throw new Error(`Unsupported identifier '${node.getText()}', only imports and are variable declarations with initializer are supported`);
-    }
-    else {
-        throw new Error(`Unsupported expression Kind ${node.getKindName()}`);
-    }
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function exportedDeclarationToJson(node) {
-    if (node.getKind() == ts_morph_1.SyntaxKind.VariableDeclaration) {
-        const variableDeclaration = node;
-        const initializer = variableDeclaration.getInitializer();
-        if (initializer) {
-            return astNodeToJson(initializer, "");
-        }
-        else {
-            throw new Error(`Initializer is required for variableDeclaration '${variableDeclaration.getName()}'`);
-        }
-    }
-    else if (node.getKind() == ts_morph_1.SyntaxKind.CallExpression) {
-        const callExpression = node;
-        if (callExpression.getExpression().getText() == "defineConfig") {
-            const args = callExpression.getArguments();
-            if (args.length != 1) {
-                throw new Error(`Expected exactly one argument for defineConfig`);
-            }
-            return astNodeToJson(args[0], "");
-        }
-        else {
-            throw new Error(`Only direct call to defineConfig is supported`);
-        }
-    }
-    else {
-        throw new Error(`Unsupported declaration kind '${node.getKindName()}'`);
-    }
-}