@comet/admin-generator 9.0.0-canary-20251002124333 → 9.0.0-canary-20251113142723

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/generateGrid.js

@@ -18,6 +18,7 @@ const convertConfigImport_1 = require("../utils/convertConfigImport");
 const findMutationType_1 = require("../utils/findMutationType");
 const findQueryType_1 = require("../utils/findQueryType");
 const findRootBlocks_1 = require("../utils/findRootBlocks");
+const generateGqlOperation_1 = require("../utils/generateGqlOperation");
 const generateImportsCode_1 = require("../utils/generateImportsCode");
 const runtimeTypeGuards_1 = require("../utils/runtimeTypeGuards");
 const findInputObjectType_1 = require("./findInputObjectType");
@@ -160,7 +161,6 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         { 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" },
@@ -179,6 +179,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         { name: "GridColumnHeaderTitle", importPath: "@mui/x-data-grid-pro" },
         { name: "GridToolbarQuickFilter", importPath: "@mui/x-data-grid-pro" },
         { name: "GridRowOrderChangeParams", importPath: "@mui/x-data-grid-pro" },
+        { name: "useMemo", importPath: "react" },
     ];
     const iconsToImport = ["Add", "Edit", "Info", "Excel"];
     const props = [];
@@ -229,9 +230,24 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
     const showCrudContextMenuInActionsColumn = allowDeleting;
     const showEditInActionsColumn = allowEditing && !forwardRowAction;
     const defaultActionsColumnWidth = getDefaultActionsColumnWidth(showCrudContextMenuInActionsColumn, showEditInActionsColumn);
-    const { imports: forwardedGqlArgsImports, props: forwardedGqlArgsProps, gqlArgs } = (0, getForwardedGqlArgs_1.getForwardedGqlArgs)([gridQueryType]);
-    imports.push(...forwardedGqlArgsImports);
-    props.push(...forwardedGqlArgsProps);
+    let useScopeFromContext = false;
+    const gqlArgs = [];
+    {
+        const forwardedArgs = (0, getForwardedGqlArgs_1.getForwardedGqlArgs)([gridQueryType]);
+        for (const forwardedArg of forwardedArgs) {
+            imports.push(...forwardedArg.imports);
+            if (forwardedArg.gqlArg.name === "scope" && !config.scopeAsProp) {
+                useScopeFromContext = true;
+            }
+            else {
+                props.push(forwardedArg.prop);
+                gqlArgs.push(forwardedArg.gqlArg);
+            }
+        }
+    }
+    if (useScopeFromContext) {
+        imports.push({ name: "useContentScope", importPath: "@comet/cms-admin" });
+    }
     const renderToolbar = (_f = config.toolbar) !== null && _f !== void 0 ? _f : true;
     const filterArg = gridQueryType.args.find((arg) => arg.name === "filter");
     const hasFilter = !!filterArg && renderToolbar && !allowRowReordering;
@@ -285,7 +301,6 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         }
     }
     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)
         throw new Error("didn't find entity in schema types");
@@ -489,7 +504,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
     if (forwardRowAction) {
         props.push({
             name: "rowAction",
-            type: `(params: GridRenderCellParams<any, GQL${fragmentName}Fragment, any>) => ReactNode`,
+            type: `(params: GridRenderCellParams<GQL${fragmentName}Fragment>) => ReactNode`,
             optional: true,
         });
         props.push({
@@ -555,31 +570,30 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         }
     \`;
 
-    const ${instanceGqlTypePlural}Query = gql\`
-        query ${gqlTypePlural}Grid(${[
-        ...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((gqlArg) => `$${gqlArg.name}: ${gqlArg.type}!`),
-        ...[`$offset: Int!`, `$limit: Int!`],
-        ...(hasSort ? [`$sort: [${gqlType}Sort!]`] : []),
-        ...(hasSearch ? [`$search: String`] : []),
-        ...(filterArg && (hasFilter || hasFilterProp) ? [`$filter: ${gqlType}Filter`] : []),
-        ...(hasScope ? [`$scope: ${gqlType}ContentScopeInput!`] : []),
-    ].join(", ")}) {
-    ${gridQuery}(${[
-        ...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((gqlArg) => `${gqlArg.name}: $${gqlArg.name}`),
-        ...[`offset: $offset`, `limit: $limit`],
-        ...(hasSort ? [`sort: $sort`] : []),
-        ...(hasSearch ? [`search: $search`] : []),
-        ...(filterArg && (hasFilter || hasFilterProp) ? [`filter: $filter`] : []),
-        ...(hasScope ? [`scope: $scope`] : []),
-    ].join(", ")}) {
-                nodes {
-                    ...${fragmentName}
-                }
-                totalCount
-            }
-        }
-        \${${instanceGqlTypePlural}Fragment}
-    \`;
+    const ${instanceGqlTypePlural}Query = gql\`${(0, generateGqlOperation_1.generateGqlOperation)({
+        type: "query",
+        operationName: `${gqlTypePlural}Grid`,
+        rootOperation: gridQuery,
+        fields: [`nodes...${fragmentName}`, "totalCount"],
+        fragmentVariables: [`\${${instanceGqlTypePlural}Fragment}`],
+        variables: [
+            ...gqlArgs
+                .filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name)
+                .map((gqlArg) => ({ name: gqlArg.name, type: `${gqlArg.type}!` })),
+            {
+                name: "offset",
+                type: "Int!",
+            },
+            {
+                name: "limit",
+                type: "Int!",
+            },
+            ...(hasSort ? [{ name: "sort", type: `[${gqlType}Sort!]` }] : []),
+            ...(hasSearch ? [{ name: "search", type: "String" }] : []),
+            ...(filterArg && (hasFilter || hasFilterProp) ? [{ name: "filter", type: `${gqlType}Filter` }] : []),
+            ...(useScopeFromContext ? [{ name: "scope", type: `${gqlType}ContentScopeInput!` }] : []),
+        ],
+    })}\`;
 
     ${allowRowReordering
         ? `const update${gqlType}PositionMutation = gql\`
@@ -627,12 +641,12 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
         : config.selectionProps === "singleSelect"
             ? `, rowSelectionModel, onRowSelectionModelChange, checkboxSelection: false, keepNonExistentRowsSelected: false, disableRowSelectionOnClick: false`
             : ``} };
-        ${hasScope ? `const { scope } = useContentScope();` : ""}
+        ${useScopeFromContext ? `const { scope } = useContentScope();` : ""}
         ${gridNeedsTheme ? `const theme = useTheme();` : ""}
 
         ${generateHandleRowOrderChange(allowRowReordering, gqlType, instanceGqlTypePlural)}
 
-        const columns: GridColDef<GQL${fragmentName}Fragment>[] = [
+        const columns: GridColDef<GQL${fragmentName}Fragment>[] = useMemo(()=>[
             ${gridColumnFields
         .map((column) => {
         const defaultMinWidth = 150;
@@ -727,7 +741,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
                             );
                                 }` }))
         : ""}
-        ];
+        ],[intl${gridNeedsTheme ? ", theme" : ""}${showCrudContextMenuInActionsColumn ? ", client" : ""}${forwardRowAction ? ", rowAction, actionsColumnWidth" : ""}]);
 
         ${hasFilter || hasSearch
         ? `const { ${hasFilter ? `filter: gqlFilter, ` : ""}${hasSearch ? `search: gqlSearch, ` : ""} } = muiGridFilterToGql(columns, dataGridProps.filterModel);`
@@ -737,7 +751,7 @@ function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntr
             variables: {
                 ${[
         ...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((arg) => arg.name),
-        ...(hasScope ? ["scope"] : []),
+        ...(useScopeFromContext ? ["scope"] : []),
         ...(filterArg
             ? hasFilter && hasFilterProp
                 ? ["filter: filter ? { and: [gqlFilter, filter] } : gqlFilter"]

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

@@ -8,6 +8,6 @@ export type GqlArg = {
 };
 export declare function getForwardedGqlArgs(gqlFields: IntrospectionField[]): {
     imports: Imports;
-    props: Prop[];
-    gqlArgs: GqlArg[];
-};
+    prop: Prop;
+    gqlArg: GqlArg;
+}[];

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

@@ -2,34 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getForwardedGqlArgs = getForwardedGqlArgs;
 function getForwardedGqlArgs(gqlFields) {
-    const supportedGqlArgs = ["offset", "limit", "sort", "search", "filter", "scope", "input"]; // this arguments need to be handled differently or are already handled somewhere else
-    const imports = [];
-    const props = [];
-    const gqlArgs = [];
+    const ret = [];
+    const supportedGqlArgs = ["offset", "limit", "sort", "search", "filter", "input"]; // this arguments need to be handled differently or are already handled somewhere else
     getArgs(gqlFields, supportedGqlArgs).forEach((arg) => {
+        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: arg.type });
-            imports.push({ name: arg.type, importPath: "@src/graphql.generated" });
+            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, queryOrMutationName: arg.gqlField.name });
+        ret.push({ gqlArg: { name: arg.name, type: arg.type, queryOrMutationName: arg.gqlField.name }, prop, imports });
     });
-    return {
-        imports,
-        props,
-        gqlArgs,
-    };
+    return ret;
 }
 function getArgs(gqlFields, skipGqlArgs) {
     return gqlFields.reduce((acc, gqlField) => {

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

@@ -2,8 +2,13 @@ type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type GqlLeaves<T, FollowArrays extends boolean = false, Depth extends number = 5> = [Depth] extends [never] ? never : T extends any ? T extends Array<infer ArrayType> ? FollowArrays extends true ? GqlLeaves<ArrayType, FollowArrays, Prev[Depth]> : never : "__typename" extends keyof T ? {
     [K in keyof T as K extends "__typename" ? never : K]-?: GqlLeaves<T[K], FollowArrays, Prev[Depth]>;
 } : never : never;
+type IfExplicitAny<T, Y, N> = T extends never ? Y : N;
 type FieldNames<T> = {
     [K in keyof T]: `${Exclude<K, symbol>}${FieldNames<T[K]> extends never ? "" : `.${FieldNames<T[K]>}`}`;
 }[keyof T];
-export type UsableFields<T, FollowArrays extends boolean = false> = FieldNames<GqlLeaves<T, FollowArrays>>;
+export type UsableFields<T, FollowArrays extends boolean = false> = IfExplicitAny<T, any, FieldNames<GqlLeaves<T, FollowArrays>>>;
+type FormFieldNames<T> = {
+    [K in keyof T]: `${Exclude<K, symbol>}` | (FormFieldNames<T[K]> extends never ? never : `${Exclude<K, symbol>}.${FormFieldNames<T[K]>}`);
+}[keyof T];
+export type UsableFormFields<T> = IfExplicitAny<T, any, FormFieldNames<GqlLeaves<T, false>>>;
 export {};

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

@@ -2,4 +2,5 @@ import { type Imports } from "./generateImportsCode";
 export declare function convertConfigImport(imprt: {
     name: string;
     import: string;
+    defaultImport?: boolean;
 }): Imports[0];

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

@@ -10,5 +10,5 @@ function convertConfigImport(imprt) {
     else if (importPath.startsWith("./")) {
         importPath = `.${importPath}`;
     }
-    return { name: imprt.name, importPath };
+    return { name: imprt.name, importPath, defaultImport: imprt.defaultImport };
 }