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

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

@@ -1,1017 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGrid = generateGrid;
-const pluralize_1 = require("pluralize");
-const camelCaseToHumanReadable_1 = require("../utils/camelCaseToHumanReadable");
-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 intl_1 = require("../utils/intl");
-const runtimeTypeGuards_1 = require("../utils/runtimeTypeGuards");
-const detectMuiXVersion_1 = require("./detectMuiXVersion");
-const findInputObjectType_1 = require("./findInputObjectType");
-const generateGqlFieldList_1 = require("./generateGqlFieldList");
-const generateGridToolbar_1 = require("./generateGridToolbar");
-const getForwardedGqlArgs_1 = require("./getForwardedGqlArgs");
-const getPropsForFilterProp_1 = require("./getPropsForFilterProp");
-function tsCodeRecordToString(object, spreadAbove) {
-    return `{${spreadAbove ? `${spreadAbove}` : ""}${Object.entries(object)
-        .filter(([key, value]) => value !== undefined)
-        .map(([key, value]) => `${key}: ${value},`)
-        .join("\n")}}`;
-}
-function generateGridPropsCode(props) {
-    if (!props.length)
-        return { gridPropsTypeCode: "", gridPropsParamsCode: "" };
-    const uniqueProps = props.reduce((acc, prop) => {
-        const propWithSameName = acc.find((filteredProps) => filteredProps.name === prop.name);
-        if (propWithSameName) {
-            if (propWithSameName.type === prop.type) {
-                // ignore prop, it's a duplicate. e.g. same prop for mutation and for query
-            }
-            else {
-                throw new Error(`Prop ${prop.name} with same name but different types (${propWithSameName.type} and ${prop.type}) detected.`);
-            }
-        }
-        else {
-            acc.push(prop);
-        }
-        return acc;
-    }, []);
-    return {
-        gridPropsTypeCode: `type Props = {
-            ${uniqueProps
-            .map((prop) => `${prop.type.includes("any")
-            ? `// eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                `
-            : ``}${prop.name}${prop.optional ? `?` : ``}: ${prop.type};`)
-            .join("\n")}
-        };`,
-        gridPropsParamsCode: `{${uniqueProps.map((prop) => `${prop.name} ${prop.defaultValue ? `= ${prop.defaultValue}` : ""}`).join(", ")}}: Props`,
-    };
-}
-const getSortByValue = (sortBy) => {
-    if (Array.isArray(sortBy)) {
-        return `[${sortBy.map((i) => `"${i}"`).join(", ")}]`;
-    }
-    if (typeof sortBy === "string") {
-        return `"${sortBy}"`;
-    }
-    return sortBy;
-};
-const getValueOptionsLabelData = (messageId, label) => {
-    if (typeof label === "string" || (0, intl_1.isFormattedMessageElement)(label)) {
-        return {
-            textLabel: (0, intl_1.generateFormattedMessage)({
-                config: label,
-                id: messageId,
-                type: "intlCall",
-            }),
-        };
-    }
-    const textLabelParts = [];
-    const gridCellContentProps = {};
-    if ("primaryText" in label && label.primaryText) {
-        const primaryMessageId = `${messageId}.primary`;
-        textLabelParts.push((0, intl_1.generateFormattedMessage)({
-            config: label.primaryText,
-            id: primaryMessageId,
-            type: "intlCall",
-        }));
-        gridCellContentProps.primaryText = (0, intl_1.generateFormattedMessage)({
-            config: label.primaryText,
-            id: primaryMessageId,
-            type: "jsx",
-        });
-    }
-    if ("secondaryText" in label && label.secondaryText) {
-        const secondaryMessageId = `${messageId}.secondary`;
-        textLabelParts.push((0, intl_1.generateFormattedMessage)({
-            config: label.secondaryText,
-            id: secondaryMessageId,
-            type: "intlCall",
-        }));
-        gridCellContentProps.secondaryText = (0, intl_1.generateFormattedMessage)({
-            config: label.secondaryText,
-            id: secondaryMessageId,
-            type: "jsx",
-        });
-    }
-    if ("icon" in label) {
-        if (typeof label.icon === "string") {
-            gridCellContentProps.icon = `<${label.icon}Icon />`;
-        }
-        else if (typeof label.icon === "object") {
-            if ("import" in label.icon) {
-                gridCellContentProps.icon = `<${label.icon.name} />`;
-            }
-            else {
-                const _a = label.icon, { name } = _a, iconProps = __rest(_a, ["name"]);
-                gridCellContentProps.icon = `<${name}Icon
-                ${Object.entries(iconProps)
-                    .map(([key, value]) => `${key}="${value}"`)
-                    .join("\n")}
-            />`;
-            }
-        }
-    }
-    const gridCellContent = `<GridCellContent
-        ${Object.entries(gridCellContentProps)
-        .map(([key, value]) => `${key}={${value}}`)
-        .join("\n")}
-    />`;
-    return {
-        textLabel: textLabelParts.join(" + ' ' + "),
-        gridCellContent,
-    };
-};
-function queryHasPaging(gridQueryType, gqlIntrospection) {
-    // Unwrap NON_NULL to get the named return type
-    let returnType = gridQueryType.type;
-    if (returnType.kind === "NON_NULL") {
-        returnType = returnType.ofType;
-    }
-    // If the return type is a LIST, there's no pagination wrapper
-    if (returnType.kind === "LIST") {
-        return false;
-    }
-    // If it's a named OBJECT type, check for nodes and totalCount fields
-    if (returnType.kind === "OBJECT") {
-        const typeName = returnType.name;
-        const objectType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === typeName);
-        if (objectType) {
-            const hasNodes = objectType.fields.some((f) => f.name === "nodes");
-            const hasTotalCount = objectType.fields.some((f) => f.name === "totalCount");
-            return hasNodes && hasTotalCount;
-        }
-    }
-    return false;
-}
-function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection, }, config) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-    const gqlType = config.gqlType;
-    if (!gqlType) {
-        throw new Error("gqlType is required in grid config");
-    }
-    const muiXGridVariant = (0, detectMuiXVersion_1.detectMuiXGridVariant)();
-    const gqlTypePlural = (0, pluralize_1.plural)(gqlType);
-    //const title = config.title ?? camelCaseToHumanReadable(gqlType);
-    const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
-    const instanceGqlTypePlural = gqlTypePlural[0].toLowerCase() + gqlTypePlural.substring(1);
-    const gridQuery = config.query ? config.query : instanceGqlType != instanceGqlTypePlural ? instanceGqlTypePlural : `${instanceGqlTypePlural}List`;
-    const gqlDocuments = {};
-    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: "dataGridIdColumn", importPath: "@comet/admin" },
-        { name: "dataGridManyToManyColumn", importPath: "@comet/admin" },
-        { name: "dataGridOneToManyColumn", importPath: "@comet/admin" },
-        { name: "renderStaticSelectCell", importPath: "@comet/admin" },
-        { name: "messages", importPath: "@comet/admin" },
-        { name: "muiGridFilterToGql", importPath: "@comet/admin" },
-        { name: "StackLink", importPath: "@comet/admin" },
-        { name: "useStackSwitchApi", importPath: "@comet/admin" },
-        { name: "FillSpace", importPath: "@comet/admin" },
-        { name: "Tooltip", importPath: "@comet/admin" },
-        { name: "useBufferedRowCount", importPath: "@comet/admin" },
-        { name: "useDataGridExcelExport", importPath: "@comet/admin" },
-        { name: "usePersistentColumnState", importPath: "@comet/admin" },
-        { name: "BlockPreviewContent", 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: muiXGridVariant.gridComponent, importPath: muiXGridVariant.package },
-        { name: `${muiXGridVariant.gridComponent}Props`, importPath: muiXGridVariant.package },
-        { name: "GridLogicOperator", importPath: muiXGridVariant.package },
-        { name: "GridRenderCellParams", importPath: muiXGridVariant.package },
-        { name: "GridSlotsComponent", importPath: muiXGridVariant.package },
-        { name: "GridToolbarProps", importPath: muiXGridVariant.package },
-        { name: "GridColumnHeaderTitle", importPath: muiXGridVariant.package },
-        { name: "GridToolbarQuickFilter", importPath: muiXGridVariant.package },
-        { name: "GridRowOrderChangeParams", importPath: muiXGridVariant.package },
-        { name: "useMemo", importPath: "react" },
-    ];
-    const iconsToImport = ["Add", "Edit", "Info", "Excel"];
-    const props = [];
-    const fieldList = (0, generateGqlFieldList_1.generateGqlFieldList)({ columns: config.columns });
-    // all root blocks including those we don't have columns for (required for copy/paste)
-    // this is not configured in the grid config, it's just an heuristics
-    const rootBlocks = (0, findRootBlocks_1.findRootBlocks)({ gqlType, targetDirectory }, gqlIntrospection);
-    const rootBlockColumns = config.columns.filter((column) => column.type == "block");
-    rootBlockColumns.forEach((field) => {
-        if (rootBlocks[String(field.name)]) {
-            // update rootBlocks if they are also used in columns
-            const block = field.block;
-            if ((0, runtimeTypeGuards_1.isGeneratorConfigImport)(block)) {
-                rootBlocks[String(field.name)].import = block.import;
-                rootBlocks[String(field.name)].name = block.name;
-            }
-        }
-    });
-    Object.values(rootBlocks).forEach((block) => {
-        if ((0, runtimeTypeGuards_1.isGeneratorConfigImport)(block)) {
-            imports.push((0, convertConfigImport_1.convertConfigImport)(block));
-        }
-    });
-    const gridQueryType = (0, findQueryType_1.findQueryTypeOrThrow)(gridQuery, gqlIntrospection);
-    const hasPaging = queryHasPaging(gridQueryType, gqlIntrospection);
-    if (hasPaging) {
-        imports.push({ name: "useDataGridRemote", importPath: "@comet/admin" });
-    }
-    else {
-        imports.push({ name: "useDataGridUrlState", importPath: "@comet/admin" });
-    }
-    const updateMutationType = (0, findMutationType_1.findMutationType)(`update${gqlType}`, gqlIntrospection);
-    const hasDeleteMutation = !!(0, findMutationType_1.findMutationType)(`delete${gqlType}`, gqlIntrospection);
-    const hasUpdateMutation = !!updateMutationType;
-    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 = allowEditing || allowDeleting;
-    const showCrudContextMenuInActionsColumn = allowDeleting;
-    const showEditInActionsColumn = allowEditing && !forwardRowAction;
-    const defaultActionsColumnWidth = getDefaultActionsColumnWidth(showCrudContextMenuInActionsColumn, showEditInActionsColumn);
-    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;
-                gqlArgs.push(forwardedArg.gqlArg);
-            }
-            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;
-    let hasFilterProp = false;
-    let filterFields = [];
-    if (filterArg) {
-        const filterType = (0, findInputObjectType_1.findInputObjectType)(filterArg, gqlIntrospection);
-        if (!filterType)
-            throw new Error("Can't find filter type");
-        filterFields = filterType.inputFields.map((f) => f.name.replace(/_/g, "."));
-        const { hasFilterProp: tempHasFilterProp, imports: filterPropImports, props: filterPropProps, } = (0, getPropsForFilterProp_1.getPropsForFilterProp)({ config, filterType });
-        hasFilterProp = tempHasFilterProp;
-        imports.push(...filterPropImports);
-        props.push(...filterPropProps);
-    }
-    const forwardToolbarAction = allowAdding && renderToolbar && config.toolbarActionProp;
-    if (forwardToolbarAction) {
-        props.push({ name: "toolbarAction", type: "ReactNode", optional: true });
-    }
-    const sortArg = gridQueryType.args.find((arg) => arg.name === "sort");
-    const hasSort = !!sortArg;
-    let sortFields = [];
-    if (sortArg) {
-        imports.push({ name: "muiGridSortToGql", importPath: "@comet/admin" });
-        let sortArgType = sortArg.type;
-        if (sortArgType.kind === "NON_NULL") {
-            sortArgType = sortArgType.ofType;
-        }
-        if (sortArgType.kind !== "LIST") {
-            throw new Error("Sort argument must be LIST");
-        }
-        if (sortArgType.ofType.kind !== "NON_NULL") {
-            throw new Error("Sort argument must be LIST->NON_NULL");
-        }
-        if (sortArgType.ofType.ofType.kind !== "INPUT_OBJECT") {
-            throw new Error("Sort argument must be LIST->NON_NULL->INPUT_OBJECT");
-        }
-        const sortTypeName = sortArgType.ofType.ofType.name;
-        const sortType = gqlIntrospection.__schema.types.find((type) => type.kind === "INPUT_OBJECT" && type.name === sortTypeName);
-        if (!sortType)
-            throw new Error("Can't find sort type");
-        const sortField = sortType.inputFields.find((i) => i.name == "field");
-        if (!sortField)
-            throw new Error("Can't find sortFieldName");
-        if (sortField.type.kind !== "NON_NULL")
-            throw new Error("sortField must be NON_NULL");
-        if (sortField.type.ofType.kind != "ENUM")
-            throw new Error("sortField must be NON_NULL->ENUM");
-        const sortFieldEnumName = sortField.type.ofType.name;
-        const sortInputEnum = gqlIntrospection.__schema.types.find((type) => type.kind === "ENUM" && type.name === sortFieldEnumName);
-        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") && !allowRowReordering;
-    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");
-    const actionsColumnConfig = config.columns.find((column) => column.type === "actions");
-    const _l = actionsColumnConfig !== null && actionsColumnConfig !== void 0 ? actionsColumnConfig : {}, { component: actionsColumnComponent, type: actionsColumnType, headerName: actionsColumnHeaderName, pinned: actionsColumnPinned = "right", width: actionsColumnWidth = defaultActionsColumnWidth, visible: actionsColumnVisible = undefined, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    queryFields: actionsColumnQueryFields = [] } = _l, // not needed here, but needs to be removed from restActionsColumnConfig because it's directly used in to generate component props in tsCodeRecordToString
-    restActionsColumnConfig = __rest(_l, ["component", "type", "headerName", "pinned", "width", "visible", "queryFields"]);
-    if (actionsColumnComponent) {
-        if (!(0, runtimeTypeGuards_1.isGeneratorConfigImport)(actionsColumnComponent)) {
-            throw new Error("Unsupported actionsColumnComponent, only imports are supported");
-        }
-        imports.push((0, convertConfigImport_1.convertConfigImport)(actionsColumnComponent));
-    }
-    const gridNeedsTheme = config.columns.some((column) => typeof column.visible === "string");
-    const gridColumnFields = config.columns.filter((column) => column.type !== "actions").map((column) => {
-        var _a;
-        const type = column.type;
-        const name = String(column.name);
-        let gridColumnType = undefined;
-        let renderCell = undefined;
-        let valueFormatter = undefined;
-        let valueGetter = name.includes(".") ? `(params, row) => row.${name.replace(/\./g, "?.")}` : undefined;
-        let gridType;
-        let filterOperators;
-        if (column.type != "virtual" && column.filterOperators) {
-            if ((0, runtimeTypeGuards_1.isGeneratorConfigImport)(column.filterOperators)) {
-                imports.push((0, convertConfigImport_1.convertConfigImport)(column.filterOperators));
-                filterOperators = column.filterOperators.name;
-            }
-            else {
-                throw new Error("Unsupported filterOperators, only imports are supported for now");
-            }
-        }
-        if (type == "dateTime") {
-            gridColumnType = "...dataGridDateTimeColumn,";
-            valueGetter = name.includes(".")
-                ? `(params, row) => row.${name.replace(/\./g, "?.")} && new Date(row.${name.replace(/\./g, "?.")})`
-                : undefined;
-        }
-        else if (type == "date") {
-            gridColumnType = "...dataGridDateColumn,";
-            valueGetter = name.includes(".")
-                ? `(params, row) => row.${name.replace(/\./g, "?.")} && new Date(row.${name.replace(/\./g, "?.")})`
-                : undefined;
-        }
-        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";
-        }
-        else if (column.type == "block") {
-            renderCell = `(params) => {
-                    return <BlockPreviewContent block={${column.block.name}} input={params.row.${name}} />;
-                }`;
-        }
-        else if (type == "staticSelect") {
-            valueFormatter = `(value, row) => row.${name}?.toString()`;
-            const introspectionField = schemaEntity.fields.find((field) => field.name === name);
-            if (!introspectionField)
-                throw new Error(`didn't find field ${name} in gql introspection type ${gqlType}`);
-            const introspectionFieldType = introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type;
-            const enumType = gqlIntrospection.__schema.types.find((t) => t.kind === "ENUM" && t.name === introspectionFieldType.name);
-            (_a = column.values) === null || _a === void 0 ? void 0 : _a.forEach((value) => {
-                var _a;
-                if (typeof value === "object" && typeof value.label === "object" && "icon" in value.label) {
-                    if (typeof value.label.icon === "string") {
-                        iconsToImport.push(value.label.icon);
-                    }
-                    else if (typeof ((_a = value.label.icon) === null || _a === void 0 ? void 0 : _a.name) === "string") {
-                        if ((0, runtimeTypeGuards_1.isGeneratorConfigImport)(value.label.icon)) {
-                            imports.push((0, convertConfigImport_1.convertConfigImport)(value.label.icon));
-                        }
-                        else {
-                            iconsToImport.push(value.label.icon.name);
-                        }
-                    }
-                }
-            });
-            let columnValues = [];
-            if (column.values) {
-                columnValues = column.values;
-            }
-            else if (enumType) {
-                columnValues = enumType.enumValues.map((i) => i.name);
-            }
-            else {
-                throw new Error(`Enum type not found`);
-            }
-            const values = columnValues.map((value) => {
-                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-                    return {
-                        value,
-                        label: (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(value.toString()),
-                    };
-                }
-                else {
-                    return value;
-                }
-            });
-            const valueOptions = `[${values
-                .map(({ value, label }) => {
-                const labelData = getValueOptionsLabelData(`${instanceGqlType}.${name}.${value.toString().charAt(0).toLowerCase() + value.toString().slice(1)}`, label);
-                return `{
-                        value: ${JSON.stringify(value)},
-                        label: ${labelData.textLabel},
-                        ${labelData.gridCellContent !== undefined ? `cellContent: ${labelData.gridCellContent},` : ""}
-                    },`;
-            })
-                .join(" ")}]`;
-            renderCell = `renderStaticSelectCell`;
-            return {
-                name,
-                headerName: column.headerName,
-                type,
-                gridType: "singleSelect",
-                columnType: gridColumnType,
-                valueOptions,
-                renderCell,
-                valueFormatter,
-                width: column.width,
-                minWidth: column.minWidth,
-                maxWidth: column.maxWidth,
-                flex: column.flex,
-                headerInfoTooltip: column.headerInfoTooltip,
-                visible: column.visible !== undefined ? (typeof column.visible == "string" ? `theme.breakpoints.${column.visible}` : "false") : undefined,
-                pinned: column.pinned,
-                disableExport: column.disableExport,
-            };
-        }
-        else if (type == "id") {
-            gridColumnType = "...dataGridIdColumn,";
-        }
-        else if (type == "manyToMany") {
-            gridColumnType = "...dataGridManyToManyColumn,";
-        }
-        else if (type == "oneToMany") {
-            gridColumnType = "...dataGridOneToManyColumn,";
-        }
-        if ((column.type == "text" ||
-            column.type == "number" ||
-            column.type == "boolean" ||
-            column.type == "date" ||
-            column.type == "dateTime" ||
-            column.type == "virtual" ||
-            column.type == "id" ||
-            column.type == "manyToMany" ||
-            column.type == "oneToMany") &&
-            column.renderCell) {
-            if ((0, runtimeTypeGuards_1.isGeneratorConfigCode)(column.renderCell)) {
-                renderCell = column.renderCell.code;
-                imports.push(...column.renderCell.imports.map((imprt) => (0, convertConfigImport_1.convertConfigImport)(imprt)));
-            }
-            else {
-                throw new Error(`Unsupported renderCell for column '${name}', only arrow functions are supported`);
-            }
-        }
-        if ((column.type === "manyToMany" || column.type === "oneToMany") && !column.renderCell) {
-            if (!column.labelField) {
-                throw new Error(`labelField is required for ${column.type} column '${name}' if no custom renderCell is provided`);
-            }
-            renderCell = `({ row }) => <>{row.${column.name}.map((${(0, pluralize_1.singular)(column.name)}) => ${(0, pluralize_1.singular)(column.name)}.${column.labelField}).join(", ")}</>`;
-        }
-        //TODO support n:1 relation with singleSelect
-        return {
-            name,
-            fieldName: column.fieldName,
-            headerName: column.headerName,
-            type,
-            gridType,
-            columnType: gridColumnType,
-            renderCell,
-            valueGetter,
-            filterOperators: filterOperators,
-            valueFormatter,
-            width: column.width,
-            minWidth: column.minWidth,
-            maxWidth: column.maxWidth,
-            flex: column.flex,
-            headerInfoTooltip: column.headerInfoTooltip,
-            visible: column.visible !== undefined ? (typeof column.visible == "string" ? `theme.breakpoints.${column.visible}` : "false") : undefined,
-            pinned: column.pinned,
-            disableExport: column.disableExport,
-            sortBy: "sortBy" in column ? column.sortBy : undefined,
-        };
-    });
-    iconsToImport.forEach((icon) => {
-        imports.push({
-            name: `${icon} as ${icon}Icon`,
-            importPath: "@comet/admin-icons",
-        });
-    });
-    const fragmentName = (_g = config.fragmentName) !== null && _g !== void 0 ? _g : `${gqlTypePlural}Form`;
-    if (forwardRowAction) {
-        props.push({
-            name: "rowAction",
-            type: `(params: GridRenderCellParams<GQL${fragmentName}Fragment>) => ReactNode`,
-            optional: true,
-        });
-        props.push({
-            name: "actionsColumnWidth",
-            type: `number`,
-            optional: true,
-            defaultValue: defaultActionsColumnWidth,
-        });
-        props.push({
-            name: "onRowClick",
-            type: `${muiXGridVariant.gridComponent}Props["onRowClick"]`,
-            optional: true,
-        });
-    }
-    if (config.selectionProps) {
-        props.push({
-            name: "rowSelectionModel",
-            type: `${muiXGridVariant.gridComponent}Props["rowSelectionModel"]`,
-            optional: true,
-        });
-        props.push({
-            name: "onRowSelectionModelChange",
-            type: `${muiXGridVariant.gridComponent}Props["onRowSelectionModelChange"]`,
-            optional: true,
-        });
-    }
-    const { gridPropsTypeCode, gridPropsParamsCode } = generateGridPropsCode(props);
-    const gridToolbarComponentName = `${gqlTypePlural}GridToolbar`;
-    const dataGridRemoteParameters = config.initialSort || config.queryParamsPrefix || config.initialFilter
-        ? `{${config.initialSort
-            ? ` initialSort: [${config.initialSort
-                .map((item) => {
-                return `{field: "${item.field}", sort: "${item.sort}"}`;
-            })
-                .join(",\n")} ], `
-            : ""}
-              ${config.initialFilter
-            ? `initialFilter:{ ${config.initialFilter.linkOperator
-                ? `linkOperator: GridLogicOperator.${config.initialFilter.linkOperator === "or" ? "Or" : "And"},`
-                : ""}
-                      items: [${config.initialFilter.items
-                .map((item) => {
-                return `{ field: "${item.field}", operator: "${item.operator}", value: "${item.value}" }`;
-            })
-                .join(",\n")} ],},`
-            : ""}
-              ${config.queryParamsPrefix ? `queryParamsPrefix: "${config.queryParamsPrefix}",` : ""}
-              }`
-        : "";
-    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";
-    ${(0, generateImportsCode_1.generateImportsCode)(imports)}
-
-    const ${instanceGqlTypePlural}Fragment = gql\`
-        fragment ${fragmentName} on ${gqlType} {
-            id
-            ${fieldList}
-        }
-    \`;
-
-    const ${instanceGqlTypePlural}Query = gql\`${(0, generateGqlOperation_1.generateGqlOperation)({
-        type: "query",
-        operationName: `${gqlTypePlural}Grid`,
-        rootOperation: gridQuery,
-        fields: hasPaging ? [`nodes...${fragmentName}`, "totalCount"] : [`...${fragmentName}`],
-        fragmentVariables: [`\${${instanceGqlTypePlural}Fragment}`],
-        variables: [
-            ...gqlArgs
-                .filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name)
-                .map((gqlArg) => ({ name: gqlArg.name, type: `${gqlArg.type}!` })),
-            ...(hasPaging
-                ? [
-                    {
-                        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` }] : []),
-        ],
-    })}\`;
-
-    ${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\`
-                mutation Delete${gqlType}($id: ID!) {
-                    delete${gqlType}(id: $id)
-                }
-            \`;`
-        : ""}
-
-
-    ${renderToolbar
-        ? (0, generateGridToolbar_1.generateGridToolbar)({
-            componentName: gridToolbarComponentName,
-            forwardToolbarAction,
-            hasSearch,
-            hasFilter,
-            allowAdding,
-            instanceGqlType,
-            gqlType,
-            excelExport: config.excelExport,
-            newEntryText: config.newEntryText,
-            fragmentName,
-        })
-        : ""}
-
-    ${gridPropsTypeCode}
-
-    export function ${gqlTypePlural}Grid(${gridPropsParamsCode}) {
-        ${showCrudContextMenuInActionsColumn ? "const client = useApolloClient();" : ""}
-        const intl = useIntl();
-        const dataGridProps = { ...${hasPaging ? "useDataGridRemote" : "useDataGridUrlState"}(${dataGridRemoteParameters}), ...usePersistentColumnState("${gqlTypePlural}Grid")${config.selectionProps === "multiSelect"
-        ? `, rowSelectionModel, onRowSelectionModelChange, checkboxSelection: true, keepNonExistentRowsSelected: true`
-        : config.selectionProps === "singleSelect"
-            ? `, rowSelectionModel, onRowSelectionModelChange, checkboxSelection: false, keepNonExistentRowsSelected: false, disableRowSelectionOnClick: false`
-            : ``} };
-        ${useScopeFromContext ? `const { scope } = useContentScope();` : ""}
-        ${gridNeedsTheme ? `const theme = useTheme();` : ""}
-        ${showEditInActionsColumn ? `const stackSwitchApi = useStackSwitchApi();` : ""}
-
-        ${generateHandleRowOrderChange(allowRowReordering, gqlType, instanceGqlTypePlural)}
-
-        ${showEditInActionsColumn
-        ? `const handleRowClick: ${muiXGridVariant.gridComponent}Props["onRowClick"] = (params) => {
-            stackSwitchApi.activatePage("edit", params.row.id);
-        };`
-        : ""}
-
-        const columns: GridColDef<GQL${fragmentName}Fragment>[] = useMemo(()=>[
-            ${gridColumnFields
-        .map((column) => {
-        const defaultMinWidth = 150;
-        const defaultColumnFlex = 1;
-        let minWidth;
-        let maxWidth;
-        let tooltipColumnWidth = column.width;
-        if (typeof column.width === "undefined") {
-            maxWidth = column.maxWidth;
-            if (typeof column.minWidth === "undefined" &&
-                (typeof column.maxWidth === "undefined" || column.maxWidth >= defaultMinWidth)) {
-                minWidth = defaultMinWidth;
-                tooltipColumnWidth = defaultMinWidth;
-            }
-            else if (typeof column.minWidth !== "undefined") {
-                minWidth = column.minWidth;
-                tooltipColumnWidth = column.minWidth;
-            }
-        }
-        let isColumnFilterable = !hasPaging
-            ? true // local (client side) sorting is always possible (no api support needed)
-            : filterFields.includes(column.name) || !!column.filterOperators;
-        if (allowRowReordering) {
-            //disable filter if rowReordering is enabled
-            isColumnFilterable = false;
-        }
-        if (column.type == "block" && !hasPaging) {
-            //blocks can't be sorted (client side)
-            isColumnFilterable = false;
-        }
-        let isColumnSortable = !hasPaging
-            ? true // local (client side) sorting is always possible (no api support needed)
-            : sortFields.includes(column.name) || !!column.sortBy;
-        if (allowRowReordering) {
-            //disable sort if rowReordering is enabled
-            isColumnSortable = false;
-        }
-        if (column.type == "block" && !hasPaging) {
-            //blocks can't be sorted (client side)
-            isColumnSortable = false;
-        }
-        const columnDefinition = {
-            field: column.fieldName ? `"${column.fieldName}"` : `"${column.name.replace(/\./g, "_")}"`, // field-name is used for api-filter, and api nests with underscore
-            renderHeader: column.headerInfoTooltip
-                ? `() => (
-                                    <>
-                                        <GridColumnHeaderTitle label={${(0, intl_1.generateFormattedMessage)({
-                    config: column.headerName,
-                    id: `${instanceGqlType}.${column.name}`,
-                    defaultMessage: (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(column.name),
-                    type: "intlCall",
-                })}} columnWidth= {${tooltipColumnWidth}}
-                              />
-                                        <Tooltip
-                                            title={${(0, intl_1.generateFormattedMessage)({
-                    config: column.headerInfoTooltip,
-                    id: `${instanceGqlType}.${column.name}.tooltip`,
-                    type: "jsx",
-                })}}
-                                        >
-                                            <InfoIcon sx={{ marginLeft: 1 }} />
-                                        </Tooltip>
-                                    </>
-                                )`
-                : undefined,
-            headerName: column.headerName === ""
-                ? `""`
-                : (0, intl_1.generateFormattedMessage)({
-                    config: column.headerName,
-                    id: `${instanceGqlType}.${column.name}`,
-                    defaultMessage: (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(column.name),
-                    type: "intlCall",
-                }),
-            type: column.gridType ? `"${column.gridType}"` : undefined,
-            filterable: isColumnFilterable ? undefined : `false`,
-            sortable: isColumnSortable ? undefined : `false`,
-            valueGetter: column.valueGetter,
-            valueFormatter: column.valueFormatter,
-            valueOptions: column.valueOptions,
-            renderCell: column.renderCell,
-            filterOperators: column.filterOperators,
-            width: column.width,
-            flex: column.flex,
-            pinned: column.pinned && `"${column.pinned}"`,
-            visible: column.visible,
-            disableExport: column.disableExport ? "true" : undefined,
-        };
-        if ("sortBy" in column && column.sortBy) {
-            columnDefinition["sortBy"] = getSortByValue(column.sortBy);
-        }
-        if (typeof column.width === "undefined") {
-            columnDefinition.flex = defaultColumnFlex;
-            columnDefinition.minWidth = minWidth;
-            columnDefinition.maxWidth = maxWidth;
-        }
-        return tsCodeRecordToString(columnDefinition, column.columnType);
-    })
-        .join(",\n")},
-                ${showActionsColumn
-        ? tsCodeRecordToString(Object.assign(Object.assign({ field: '"actions"', headerName: actionsColumnHeaderName
-                ? (0, intl_1.generateFormattedMessage)({
-                    config: actionsColumnHeaderName,
-                    id: `${instanceGqlType}.actions`,
-                    type: "intlCall",
-                })
-                : `""`, sortable: "false", filterable: "false", type: '"actions"', align: '"right"', pinned: `"${actionsColumnPinned}"`, width: forwardRowAction ? "actionsColumnWidth" : actionsColumnWidth, visible: actionsColumnVisible !== undefined
-                ? typeof actionsColumnVisible == "string"
-                    ? `theme.breakpoints.${actionsColumnVisible}`
-                    : "false"
-                : undefined }, restActionsColumnConfig), { headerInfoTooltip: restActionsColumnConfig.headerInfoTooltip
-                ? (0, intl_1.generateFormattedMessage)({
-                    config: restActionsColumnConfig.headerInfoTooltip,
-                    id: `${instanceGqlType}.actions`,
-                    type: "intlCall",
-                })
-                : undefined, disableExport: config.excelExport ? "true" : undefined, renderCell: `(params) => {
-                            return (
-                                <>
-                                ${(actionsColumnComponent === null || actionsColumnComponent === void 0 ? void 0 : actionsColumnComponent.name) ? `<${actionsColumnComponent.name} {...params} />` : ""}${allowEditing
-                ? forwardRowAction
-                    ? `{rowAction && rowAction(params)}`
-                    : `
-                                        <IconButton color="primary" component={StackLink} pageName="edit" payload={params.row.id}>
-                                            <EditIcon />
-                                        </IconButton>`
-                : ""}${showCrudContextMenuInActionsColumn
-                ? `
-                                        <CrudContextMenu
-                                            ${allowDeleting
-                    ? `
-                                            onDelete={async () => {
-                                                await client.mutate<GQLDelete${gqlType}Mutation, GQLDelete${gqlType}MutationVariables>({
-                                                    mutation: delete${gqlType}Mutation,
-                                                    variables: { id: params.row.id },
-                                                });
-                                            }}
-                                            `
-                    : ""}
-                                            refetchQueries={[${instanceGqlTypePlural}Query]}
-                                            ${((_h = config.crudContextMenu) === null || _h === void 0 ? void 0 : _h.deleteType) ? `deleteType="${config.crudContextMenu.deleteType}"` : ""}
-                                            ${((_j = config.crudContextMenu) === null || _j === void 0 ? void 0 : _j.deleteText) ? `messagesMapping={{ delete: <FormattedMessage id="${instanceGqlType}.crudContextMenu.delete" defaultMessage="${config.crudContextMenu.deleteText}" /> }}` : ""}
-                                        />
-                                    `
-                : ""}
-                                </>
-                            );
-                                }` }))
-        : ""}
-        ],[intl${gridNeedsTheme ? ", theme" : ""}${showCrudContextMenuInActionsColumn ? ", client" : ""}${forwardRowAction ? ", rowAction, actionsColumnWidth" : ""}]);
-
-        ${hasFilter || hasSearch
-        ? `const { ${hasFilter ? `filter: gqlFilter, ` : ""}${hasSearch ? `search: gqlSearch, ` : ""} } = muiGridFilterToGql(columns, dataGridProps.filterModel);`
-        : ""}
-
-        const { data, loading, error } = useQuery<GQL${gqlTypePlural}GridQuery, GQL${gqlTypePlural}GridQueryVariables>(${instanceGqlTypePlural}Query, {
-            variables: {
-                ${[
-        ...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((arg) => arg.name),
-        ...(filterArg
-            ? hasFilter && hasFilterProp
-                ? ["filter: filter ? { and: [gqlFilter, filter] } : gqlFilter"]
-                : hasFilter
-                    ? ["filter: gqlFilter"]
-                    : hasFilterProp
-                        ? ["filter"]
-                        : []
-            : []),
-        ...(hasSearch ? ["search: gqlSearch"] : []),
-        ...(hasSort
-            ? !allowRowReordering
-                ? ["sort: muiGridSortToGql(dataGridProps.sortModel, columns)"]
-                : [`sort: { field: "position", direction: "ASC" }`]
-            : []),
-        ...(hasPaging
-            ? !allowRowReordering
-                ? [
-                    `offset: dataGridProps.paginationModel.page * dataGridProps.paginationModel.pageSize`,
-                    `limit: dataGridProps.paginationModel.pageSize`,
-                ]
-                : // 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`]
-            : []),
-    ].join(", ")}
-            },
-        });
-        ${hasPaging ? `const rowCount = useBufferedRowCount(data?.${gridQuery}.totalCount);` : ""}
-        if (error) throw error;
-        const rows = ${!allowRowReordering
-        ? hasPaging
-            ? `data?.${gridQuery}.nodes`
-            : `data?.${gridQuery}`
-        : generateRowReorderingRows(gridQuery, fieldList, (_k = config.rowReordering) === null || _k === void 0 ? void 0 : _k.dragPreviewField)} ?? [];
-
-        ${generateGridExportApi(config.excelExport, gqlTypePlural, instanceGqlTypePlural, gridQuery, gqlArgs, hasPaging)}
-
-        return (
-            <${muiXGridVariant.gridComponent}
-                {...dataGridProps}
-                rows={rows}
-                ${hasPaging ? `rowCount={rowCount}` : ""}
-                columns={columns}
-                loading={loading}
-                ${renderToolbar
-        ? `slots={{
-                                toolbar: ${gridToolbarComponentName} as GridSlotsComponent["toolbar"],
-                            }}
-                            ${getDataGridSlotProps(gridToolbarComponentName, forwardToolbarAction, config.excelExport)}`
-        : ""}
-                ${allowRowReordering
-        ? `rowReordering
-                           onRowOrderChange={handleRowOrderChange}
-                           hideFooterPagination`
-        : ""}
-                ${config.density ? `density="${config.density}"` : ""}
-                ${showEditInActionsColumn ? `onRowClick={handleRowClick}` : forwardRowAction ? `onRowClick={onRowClick}` : ""}
-            />
-        );
-    }
-    `;
-    return {
-        code,
-        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) {
-        numberOfActions += 1;
-    }
-    if (showEdit) {
-        numberOfActions += 1;
-    }
-    const widthOfSingleAction = 32;
-    const spacingAroundActions = 20;
-    return numberOfActions * widthOfSingleAction + spacingAroundActions;
-};
-const getDataGridSlotProps = (componentName, forwardToolbarAction, excelExport) => {
-    if (!forwardToolbarAction && !excelExport) {
-        return "";
-    }
-    const values = `{
-        ${forwardToolbarAction ? `toolbarAction,` : ""}
-        ${excelExport ? `exportApi,` : ""}
-    } as ${componentName}ToolbarProps`.replace(/\n/g, "");
-    return `slotProps={{
-        toolbar: ${values}  
-    }}`;
-};
-const generateGridExportApi = (excelExport, gqlTypePlural, instanceGqlTypePlural, gridQuery, gqlArgs, hasPaging) => {
-    if (!excelExport) {
-        return "";
-    }
-    const queryNodeType = hasPaging ? `GQL${gqlTypePlural}GridQuery["${gridQuery}"]["nodes"][0]` : `GQL${gqlTypePlural}GridQuery["${gridQuery}"][0]`;
-    const variablesType = hasPaging ? `Omit<GQL${gqlTypePlural}GridQueryVariables, "offset" | "limit">` : `GQL${gqlTypePlural}GridQueryVariables`;
-    const resolveQueryNodes = hasPaging ? `(data) => data.${gridQuery}.nodes` : `(data) => data.${gridQuery}`;
-    const totalCount = hasPaging ? `data?.${gridQuery}.totalCount ?? 0` : `data?.${gridQuery}.length ?? 0`;
-    return `const exportApi = useDataGridExcelExport<${queryNodeType}, GQL${gqlTypePlural}GridQuery, ${variablesType}>({
-        columns,
-        variables: {
-            ${[
-        ...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQuery).map((arg) => arg.name),
-        `...muiGridFilterToGql(columns, dataGridProps.filterModel)`,
-    ].join(", ")}
-        },
-        query: ${instanceGqlTypePlural}Query,
-        resolveQueryNodes: ${resolveQueryNodes},
-        totalCount: ${totalCount},
-        ${!hasPaging ? `hasPaging: false,` : ""}
-        exportOptions: {
-            fileName: "${gqlTypePlural}",
-        },
-    });`;
-};
-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]
-        });
-    };`;
-};