@comet/admin-generator 9.0.0-canary-20251013121422 → 9.0.0-canary-20251124092450

package/lib/commands/generate/generateForm/generateFormValues.d.ts

@@ -0,0 +1,39 @@
+import { type IntrospectionQuery } from "graphql";
+import { type GenerateFieldsReturn } from "./generateFields";
+type FormValuesConfigTreeNode = {
+    config?: GenerateFieldsReturn["formValuesConfig"][0];
+    nullable?: boolean;
+    children: FormValuesConfigTree;
+};
+type FormValuesConfigTree = {
+    [key: string]: FormValuesConfigTreeNode;
+};
+export declare function formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType, }: {
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}): FormValuesConfigTree;
+export declare function generateFormValuesType({ formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType, }: {
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    filterByFragmentType: string;
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}): string;
+export declare function generateInitialValues({ mode, formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType, }: {
+    mode: "all" | "edit" | "add";
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    filterByFragmentType: string;
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}): string;
+export declare function generateDestructFormValueForInput({ formValuesConfig, gqlIntrospection, gqlType, }: {
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}): string;
+export declare function generateFormValuesToGqlInput({ formValuesConfig, gqlIntrospection, gqlType, }: {
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
+}): string;
+export {};

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

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formValuesConfigToTree = formValuesConfigToTree;
+exports.generateFormValuesType = generateFormValuesType;
+exports.generateInitialValues = generateInitialValues;
+exports.generateDestructFormValueForInput = generateDestructFormValueForInput;
+exports.generateFormValuesToGqlInput = generateFormValuesToGqlInput;
+// internal represenstation of formValuesConfig as tree to allow recursive processing
+function formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType, }) {
+    const treeRoot = { children: {} };
+    for (const formValueConfig of formValuesConfig) {
+        const fieldName = formValueConfig.fieldName;
+        let currentTreeNode = treeRoot;
+        let currentGqlType = gqlType;
+        for (const part of fieldName.split(".")) {
+            const introspectionObject = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === currentGqlType);
+            if (!introspectionObject)
+                throw new Error(`didn't find object ${gqlType} in gql introspection`);
+            const introspectionField = introspectionObject.fields.find((field) => field.name === part);
+            const introspectionFieldType = introspectionField
+                ? introspectionField.type.kind === "NON_NULL"
+                    ? introspectionField.type.ofType
+                    : introspectionField.type
+                : undefined;
+            if ((introspectionFieldType === null || introspectionFieldType === void 0 ? void 0 : introspectionFieldType.kind) === "OBJECT") {
+                // for next loop iteration (nested fields)
+                currentGqlType = introspectionFieldType.name;
+            }
+            if (!currentTreeNode.children[part]) {
+                currentTreeNode.children[part] = { children: {} };
+            }
+            currentTreeNode.children[part].nullable = (introspectionField === null || introspectionField === void 0 ? void 0 : introspectionField.type.kind) !== "NON_NULL";
+            currentTreeNode = currentTreeNode.children[part];
+        }
+        currentTreeNode.config = formValueConfig;
+    }
+    return treeRoot.children;
+}
+function generateFormValuesTypeFromTree(tree, currentTypeName, currentIsNullable) {
+    var _a, _b, _c;
+    const omitKeys = [];
+    let appendCode = "";
+    for (const [key, value] of Object.entries(tree)) {
+        if (Object.keys(value.children).length > 0) {
+            let childRootType = `${currentTypeName}["${key}"]`;
+            if (currentIsNullable) {
+                childRootType = `NonNullable<${currentTypeName}>["${key}"]`;
+            }
+            const childOmit = generateFormValuesTypeFromTree(value.children, childRootType, (_a = value.nullable) !== null && _a !== void 0 ? _a : false);
+            if (childOmit !== childRootType) {
+                appendCode += `${key}: ${childOmit}`;
+                omitKeys.push(key);
+            }
+            if ((_b = value.config) === null || _b === void 0 ? void 0 : _b.typeCode) {
+                throw new Error("Field has both subfields and direct typeCode, which is not supported.");
+            }
+            if ((_c = value.config) === null || _c === void 0 ? void 0 : _c.omitFromFragmentType) {
+                throw new Error("Field has both subfields and direct omitFromFragmentType, which is not supported.");
+            }
+        }
+        else if (value.config) {
+            if (value.config.typeCode) {
+                appendCode += `${key}${value.config.typeCode.nullable ? "?" : ""}: ${value.config.typeCode.type}; `;
+            }
+            if (value.config.omitFromFragmentType) {
+                omitKeys.push(key);
+            }
+        }
+    }
+    let code = omitKeys.length
+        ? `Omit<${currentIsNullable ? `NonNullable<` : ""}${currentTypeName}${currentIsNullable ? `>` : ""}, ${omitKeys.map((k) => `"${k}"`).join(" | ")}>`
+        : currentTypeName;
+    if (appendCode.length) {
+        code += ` & { ${appendCode} }`;
+    }
+    return code;
+}
+function generateFormValuesType({ formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType, }) {
+    const tree = formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType });
+    return `type FormValues = ${generateFormValuesTypeFromTree(tree, filterByFragmentType, false)};`;
+}
+function generateInitialValuesFromTree(tree, dataObject, generationType) {
+    var _a;
+    let code = "";
+    for (const [key, value] of Object.entries(tree)) {
+        if (Object.keys(value.children).length > 0) {
+            let childCode = generateInitialValuesFromTree(value.children, `${dataObject}.${key}`, generationType);
+            if (childCode.length) {
+                if (generationType == "initializationCode") {
+                    childCode = `{ ...${dataObject}.${key}, ${childCode} }`;
+                    if (value.nullable) {
+                        code += `${key}: ${dataObject}.${key} ? ${childCode} : undefined, `;
+                    }
+                    else {
+                        code += `${key}: ${childCode}, `;
+                    }
+                }
+                else {
+                    code += `${key}: { ${childCode} }, `;
+                }
+            }
+            if ((_a = value.config) === null || _a === void 0 ? void 0 : _a[generationType]) {
+                throw new Error("Field has both subfields and direct initialization code, which is not supported.");
+            }
+        }
+        else if (value.config) {
+            if (value.config[generationType]) {
+                code += `${key}: ${value.config[generationType]}, `;
+            }
+        }
+    }
+    return code;
+}
+function generateInitialValues({ mode, formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType, }) {
+    const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
+    const editMode = mode === "edit" || mode == "all";
+    const tree = formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType });
+    if (editMode) {
+        return `const initialValues = useMemo<Partial<FormValues>>(() => data?.${instanceGqlType}
+            ? {
+                ...filterByFragment<${filterByFragmentType}>(${instanceGqlType}FormFragment, data.${instanceGqlType}),
+                ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "initializationCode")}
+            }
+            : {
+                ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "defaultInitializationCode")}
+            }
+        , [data]);`;
+    }
+    else {
+        return `const initialValues = {
+            ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "defaultInitializationCode")}
+        };`;
+    }
+}
+function generateDestructFormValueForInputFromTree(tree, restObject) {
+    let code = "";
+    for (const [key, value] of Object.entries(tree)) {
+        if (Object.keys(value.children).length > 0) {
+            const childCode = generateDestructFormValueForInputFromTree(value.children, `${restObject}${key.substring(0, 1).toUpperCase()}${key.substring(1)}`);
+            if (childCode.length) {
+                code += `${key}: { ${childCode} }, `;
+            }
+        }
+        else if (value.config) {
+            if (value.config.destructFromFormValues) {
+                code += `${key}, `;
+            }
+        }
+    }
+    if (code.length) {
+        code += `...${restObject}Rest`;
+        return code;
+    }
+    else {
+        return "";
+    }
+}
+function generateDestructFormValueForInput({ formValuesConfig, gqlIntrospection, gqlType, }) {
+    const tree = formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType });
+    const code = generateDestructFormValueForInputFromTree(tree, "formValues");
+    return code.length ? `{ ${code} }` : "formValues";
+}
+function generateFormValuesToGqlInputFromTree(tree, dataObject, restObject) {
+    var _a, _b;
+    let code = "";
+    for (const [key, value] of Object.entries(tree)) {
+        if (Object.keys(value.children).length > 0) {
+            const childRestObject = `${restObject.replace(/Rest$/, "")}${key.substring(0, 1).toUpperCase()}${key.substring(1)}Rest`;
+            const hasChildDestruct = hasChildDestructTree(value.children);
+            let childCode = generateFormValuesToGqlInputFromTree(value.children, hasChildDestruct ? childRestObject : `${dataObject}.${key}`, childRestObject);
+            if (childCode.length || hasChildDestruct) {
+                childCode = `{ ...${hasChildDestruct ? childRestObject : `${dataObject}.${key}`}, ${childCode} }`;
+                if ((_a = value.config) === null || _a === void 0 ? void 0 : _a.wrapFormValueToGqlInputCode) {
+                    childCode = value.config.wrapFormValueToGqlInputCode
+                        .replaceAll("$fieldName", `${dataObject}.${key}`)
+                        .replaceAll("$inner", childCode);
+                }
+                code += `${key}: ${childCode}, `;
+            }
+            if ((_b = value.config) === null || _b === void 0 ? void 0 : _b.formValueToGqlInputCode) {
+                throw new Error("Field has both subfields and direct formValueToGqlInputCode, which is not supported.");
+            }
+        }
+        else if (value.config) {
+            if (value.config.formValueToGqlInputCode) {
+                code += `${key}: ${value.config.formValueToGqlInputCode.replaceAll("$fieldName", `${dataObject}.${key}`)}, `;
+            }
+        }
+    }
+    return code;
+}
+function hasChildDestructTree(tree) {
+    return Object.values(tree).some((childValue) => {
+        var _a;
+        if ((_a = childValue.config) === null || _a === void 0 ? void 0 : _a.destructFromFormValues) {
+            return true;
+        }
+        if (Object.keys(childValue.children).length > 0) {
+            return hasChildDestructTree(childValue.children);
+        }
+        return false;
+    });
+}
+function generateFormValuesToGqlInput({ formValuesConfig, gqlIntrospection, gqlType, }) {
+    const tree = formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType });
+    const hasChildDestruct = hasChildDestructTree(tree);
+    const code = generateFormValuesToGqlInputFromTree(tree, hasChildDestruct ? "formValuesRest" : "formValues", hasChildDestruct ? "formValuesRest" : "formValues");
+    if (code.length) {
+        return `const output = { ...${hasChildDestruct ? "formValuesRest" : "formValues"}, ${code} };`;
+    }
+    else if (hasChildDestruct) {
+        return `const output = formValuesRest;`;
+    }
+    else {
+        return `const output = formValues;`;
+    }
+}

package/lib/commands/generate/generateForm/generateFragmentByFormFragmentFields.d.ts

@@ -1,7 +1,7 @@
 /**
  * Helper function that generates a GraphQL fragment from form fragment fields (array of dot.separated.fields).
  *
- * - Fragments are supported as "foo { ...FragmentName }"
+ * - Fragments are supported as "foo...FragmentName"
  * - for FinalFormFileUpload and FinalFormFileUploadDownloadable the needed variable is added automatically
  */
 export declare function generateFragmentByFormFragmentFields({ formFragmentName, gqlType, formFragmentFields, }: {

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

@@ -1,50 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFragmentByFormFragmentFields = generateFragmentByFormFragmentFields;
-const object_path_1 = __importDefault(require("object-path"));
+const generateGqlOperation_1 = require("../utils/generateGqlOperation");
 /**
  * Helper function that generates a GraphQL fragment from form fragment fields (array of dot.separated.fields).
  *
- * - Fragments are supported as "foo { ...FragmentName }"
+ * - Fragments are supported as "foo...FragmentName"
  * - for FinalFormFileUpload and FinalFormFileUploadDownloadable the needed variable is added automatically
  */
 function generateFragmentByFormFragmentFields({ formFragmentName, gqlType, formFragmentFields, }) {
-    // 1. create tree out of dot separated fields
-    const fieldsObject = formFragmentFields.reduce((acc, field) => {
-        const fragmentMatch = field.match(/(.*)({.*?})/); // keep { ... } parts as they are, contains eg. fragments
-        if (fragmentMatch) {
-            object_path_1.default.set(acc, fragmentMatch[1].trim(), fragmentMatch[2]);
-        }
-        else {
-            object_path_1.default.set(acc, field, true);
-        }
-        return acc;
-    }, {});
-    // 2. create fragment string out of tree
-    const recursiveStringify = (obj) => {
-        let ret = "";
-        let prefixField = "";
-        for (const key in obj) {
-            const value = obj[key];
-            if (typeof value === "boolean") {
-                ret += `${prefixField}${key}`;
-            }
-            else if (typeof value === "string") {
-                ret += `${prefixField}${key} ${value}`;
-            }
-            else {
-                ret += `${prefixField}${key} { ${recursiveStringify(value)} }`;
-            }
-            prefixField = " ";
-        }
-        return ret;
-    };
     let fragmentCode = `
         fragment ${formFragmentName} on ${gqlType} {
-            ${recursiveStringify(fieldsObject)}
+            ${(0, generateGqlOperation_1.generateGqlQueryTreeFromFields)(formFragmentFields)}
         }
     `;
     // 3. add fragment instance variables when fragments are used

package/lib/commands/generate/generateForm/getForwardedGqlArgs.d.ts

@@ -2,7 +2,7 @@ import { type IntrospectionField, type IntrospectionQuery } from "graphql";
 import { type FormFieldConfig } from "../generate-command";
 import { type Imports } from "../utils/generateImportsCode";
 import { type Prop } from "./generateForm";
-type GqlArg = {
+export type GqlArg = {
     type: string;
     name: string;
     isInputArgSubfield: boolean;
@@ -13,7 +13,6 @@ export declare function getForwardedGqlArgs({ fields, gqlOperation, gqlIntrospec
     gqlIntrospection: IntrospectionQuery;
 }): {
     imports: Imports;
-    props: Prop[];
-    gqlArgs: GqlArg[];
-};
-export {};
+    prop: Prop;
+    gqlArg: GqlArg;
+}[];

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

@@ -2,36 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getForwardedGqlArgs = getForwardedGqlArgs;
 function getForwardedGqlArgs({ fields, gqlOperation, gqlIntrospection, }) {
-    const imports = [];
-    const props = [];
-    const gqlArgs = [];
-    const skipGqlInputArgFields = fields.map((field) => String(field.name));
+    const ret = [];
     getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection).forEach((arg) => {
-        if (arg.isInputArgSubfield && skipGqlInputArgFields.includes(arg.name))
-            return;
+        if (arg.isInputArgSubfield) {
+            if (fields.some((field) => {
+                return field.name === arg.name || field.name.startsWith(`${arg.name}.`);
+            })) {
+                // there is a field (or subfield) in this form, no need to forward this arg
+                return;
+            }
+        }
+        let prop;
+        const imports = [];
         if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") {
-            props.push({ name: arg.name, optional: false, type: "string" });
+            prop = { name: arg.name, optional: false, type: "string" };
         }
         else if (arg.type === "Boolean") {
-            props.push({ name: arg.name, optional: false, type: "boolean" });
+            prop = { name: arg.name, optional: false, type: "boolean" };
         }
         else if (arg.type === "Int" || arg.type === "Float") {
-            props.push({ name: arg.name, optional: false, type: "number" });
+            prop = { name: arg.name, optional: false, type: "number" };
         }
         else if (arg.type === "JSONObject") {
-            props.push({ name: arg.name, optional: false, type: "unknown" });
+            prop = { name: arg.name, optional: false, type: "unknown" };
         }
         else {
-            props.push({ name: arg.name, optional: false, type: `GQL${arg.type}` }); // generated types contain GQL prefix
+            prop = { name: arg.name, optional: false, type: `GQL${arg.type}` }; // generated types contain GQL prefix
             imports.push({ name: `GQL${arg.type}`, importPath: "@src/graphql.generated" });
         }
-        gqlArgs.push({ name: arg.name, type: arg.type, isInputArgSubfield: arg.isInputArgSubfield });
+        ret.push({ gqlArg: arg, prop, imports });
     });
-    return {
-        imports,
-        props,
-        gqlArgs,
-    };
+    return ret;
 }
 function getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection) {
     const nativeScalars = ["ID", "String", "Boolean", "Int", "Float", "DateTime", "JSONObject"];

package/lib/commands/generate/generateGrid/detectMuiXVersion.d.ts

@@ -0,0 +1,5 @@
+export declare function detectMuiXGridVariant(): {
+    variant: "community" | "pro" | "premium";
+    package: string;
+    gridComponent: string;
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMuiXGridVariant = detectMuiXGridVariant;
+const fs_1 = __importDefault(require("fs"));
+function detectMuiXGridVariant() {
+    const packageJson = JSON.parse(fs_1.default.readFileSync("package.json", "utf-8"));
+    const packages = Object.keys(packageJson.dependencies);
+    if (packages.includes("@mui/x-data-grid-premium")) {
+        return {
+            variant: "premium",
+            package: "@mui/x-data-grid-premium",
+            gridComponent: "DataGridPremium",
+        };
+    }
+    else if (packages.includes("@mui/x-data-grid-pro")) {
+        return {
+            variant: "pro",
+            package: "@mui/x-data-grid-pro",
+            gridComponent: "DataGridPro",
+        };
+    }
+    else {
+        return {
+            variant: "community",
+            package: "@mui/x-data-grid",
+            gridComponent: "DataGrid",
+        };
+    }
+}