@comet/admin-generator 8.0.0-beta.0

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFormLayout = void 0;
+const camelCaseToHumanReadable_1 = require("../utils/camelCaseToHumanReadable");
+const generateFields_1 = require("./generateFields");
+function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, formFragmentName, formConfig, gqlType, namePrefix, }) {
+    var _a, _b, _c, _d, _e;
+    const rootGqlType = formConfig.gqlType;
+    const formattedMessageRootId = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
+    const dataRootName = rootGqlType[0].toLowerCase() + rootGqlType.substring(1); // TODO should probably be deteced via query
+    let code = "";
+    let hooksCode = "";
+    let formValueToGqlInputCode = "";
+    const formFragmentFields = [];
+    const gqlDocuments = {};
+    const imports = [];
+    const formValuesConfig = [];
+    const finalFormConfig = { subscription: {}, renderProps: {} };
+    if (config.type === "fieldSet") {
+        const title = (_a = config.title) !== null && _a !== void 0 ? _a : (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(config.name);
+        const generatedFields = (0, generateFields_1.generateFields)({
+            gqlIntrospection,
+            baseOutputFilename,
+            fields: config.fields,
+            formFragmentName,
+            formConfig,
+            gqlType,
+            namePrefix,
+        });
+        hooksCode += generatedFields.hooksCode;
+        formValueToGqlInputCode += generatedFields.formValueToGqlInputCode;
+        formFragmentFields.push(...generatedFields.formFragmentFields);
+        for (const name in generatedFields.gqlDocuments) {
+            gqlDocuments[name] = generatedFields.gqlDocuments[name];
+        }
+        imports.push(...generatedFields.imports);
+        formValuesConfig.push(...generatedFields.formValuesConfig);
+        finalFormConfig.subscription = Object.assign(Object.assign({}, finalFormConfig.subscription), (_b = generatedFields.finalFormConfig) === null || _b === void 0 ? void 0 : _b.subscription);
+        finalFormConfig.renderProps = Object.assign(Object.assign({}, finalFormConfig.renderProps), (_c = generatedFields.finalFormConfig) === null || _c === void 0 ? void 0 : _c.renderProps);
+        imports.push({ name: "FieldSet", importPath: "@comet/admin" });
+        const supportPlaceholder = (_d = config.supportText) === null || _d === void 0 ? void 0 : _d.includes("{");
+        if (supportPlaceholder) {
+            imports.push({ name: "FormSpy", importPath: "react-final-form" });
+        }
+        code = `
+        <FieldSet
+            ${config.collapsible === undefined || config.collapsible ? `collapsible` : ``}
+            ${config.initiallyExpanded != null ? `initiallyExpanded={${config.initiallyExpanded}}` : ``}
+            title={<FormattedMessage id="${formattedMessageRootId}.${config.name}.title" defaultMessage="${title}" />}
+            ${config.supportText
+            ? `supportText={
+                        ${supportPlaceholder ? `mode === "edit" && (<FormSpy subscription={{ values: true }}>{({ values }) => (` : ``}
+                        <FormattedMessage
+                            id="${formattedMessageRootId}.${config.name}.supportText"
+                            defaultMessage="${config.supportText}"
+                            ${supportPlaceholder ? `values={{ ...values }}` : ``}
+                        />
+                        ${supportPlaceholder ? `)}</FormSpy>)` : ``}
+                    }`
+            : ``}
+        >
+            ${generatedFields.code}
+        </FieldSet>`;
+    }
+    else if (config.type === "optionalNestedFields") {
+        const name = String(config.name);
+        const introspectionObject = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+        if (!introspectionObject)
+            throw new Error(`didn't find object ${gqlType} in gql introspection`);
+        const introspectionField = introspectionObject.fields.find((field) => field.name === name);
+        if (!introspectionField)
+            throw new Error(`didn't find field ${name} in gql introspection type ${gqlType}`);
+        if (introspectionField.type.kind === "NON_NULL") {
+            throw new Error(`field ${name} in gql introspection type ${gqlType} must not be required to be usable with optionalNestedFields`);
+        }
+        if (introspectionField.type.kind !== "OBJECT")
+            throw new Error(`field ${name} in gql introspection type ${gqlType} has to be OBJECT`);
+        const checkboxLabel = (_e = config.checkboxLabel) !== null && _e !== void 0 ? _e : `Enable ${(0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(String(config.name))}`;
+        const generatedFields = (0, generateFields_1.generateFields)({
+            gqlIntrospection,
+            baseOutputFilename,
+            fields: config.fields,
+            formFragmentName,
+            formConfig,
+            gqlType: introspectionField.type.name,
+            namePrefix: name,
+        });
+        hooksCode += generatedFields.hooksCode;
+        formFragmentFields.push(`${name} { ${generatedFields.formFragmentFields.join(" ")} }`);
+        for (const name in generatedFields.gqlDocuments) {
+            gqlDocuments[name] = generatedFields.gqlDocuments[name];
+        }
+        imports.push(...generatedFields.imports);
+        const wrappingFormValuesConfig = {
+            omitFromFragmentType: name,
+            destructFromFormValues: `${name}Enabled`,
+            typeCode: `${name}Enabled: boolean;`,
+            initializationCode: `${name}Enabled: !!data.${dataRootName}.${name}`,
+        };
+        const subfieldsFormValuesTypeCode = generatedFields.formValuesConfig
+            .filter((config) => !!config.omitFromFragmentType)
+            .map((config) => `"${config.omitFromFragmentType}"`);
+        if (subfieldsFormValuesTypeCode.length) {
+            wrappingFormValuesConfig.typeCode = `${wrappingFormValuesConfig.typeCode}
+                ${name}: Omit<NonNullable<GQL${formFragmentName}Fragment["${name}"]>, ${subfieldsFormValuesTypeCode.join(" | ")}> & {
+                    ${generatedFields.formValuesConfig.map((config) => config.typeCode).join("\n")}
+                };`;
+        }
+        const subfieldsFormValuesInitCode = generatedFields.formValuesConfig
+            .filter((config) => !!config.initializationCode)
+            .map((config) => config.initializationCode);
+        if (subfieldsFormValuesInitCode.length) {
+            wrappingFormValuesConfig.initializationCode = `${wrappingFormValuesConfig.initializationCode},
+                ${name}: data.${dataRootName}.${name} ? { ${subfieldsFormValuesInitCode.join(", ")}} : undefined    `;
+        }
+        const subfieldsFormValuesDefaultInitCode = generatedFields.formValuesConfig
+            .filter((config) => !!config.defaultInitializationCode)
+            .map((config) => config.defaultInitializationCode);
+        if (subfieldsFormValuesDefaultInitCode.length) {
+            wrappingFormValuesConfig.defaultInitializationCode = `${name}: { ${subfieldsFormValuesDefaultInitCode.join(", ")}}`;
+        }
+        formValuesConfig.push(wrappingFormValuesConfig);
+        imports.push({ name: "FinalFormSwitch", importPath: "@comet/admin" });
+        imports.push({ name: "messages", importPath: "@comet/admin" });
+        imports.push({ name: "FormControlLabel", importPath: "@mui/material" });
+        formValueToGqlInputCode += `${String(config.name)}: ${String(config.name)}Enabled && formValues.${String(config.name)} ? {${generatedFields.formValueToGqlInputCode}} : null,`;
+        code = `<Field
+                    fullWidth
+                    name="${String(config.name)}Enabled"
+                    type="checkbox"
+                    label={<FormattedMessage id="${formattedMessageRootId}.${String(config.name)}.${String(config.name)}Enabled" defaultMessage="${checkboxLabel}" />}
+                >
+                    {(props) => (
+                        <FormControlLabel
+                            control={<FinalFormSwitch {...props} />}
+                            label={props.input.checked ? <FormattedMessage {...messages.yes} /> : <FormattedMessage {...messages.no} />}
+                        />
+                    )}
+                </Field>
+                 <Field name="${String(config.name)}Enabled" fullWidth subscription={{ value: true }}>
+                    {({ input: { value } }) =>
+                        value ? (
+                            <>
+                                ${generatedFields.code}
+                            </>
+                            ) : null
+                    }
+                </Field>`;
+    }
+    else {
+        throw new Error(`Unsupported type`);
+    }
+    return {
+        code,
+        hooksCode,
+        formValueToGqlInputCode,
+        formFragmentFields,
+        gqlDocuments,
+        imports,
+        formValuesConfig,
+        finalFormConfig,
+    };
+}
+exports.generateFormLayout = generateFormLayout;

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

@@ -0,0 +1,19 @@
+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 = {
+    type: string;
+    name: string;
+    isInputArgSubfield: boolean;
+};
+export declare function getForwardedGqlArgs({ fields, gqlOperation, gqlIntrospection, }: {
+    fields: FormFieldConfig<any>[];
+    gqlOperation: IntrospectionField;
+    gqlIntrospection: IntrospectionQuery;
+}): {
+    imports: Imports;
+    props: Prop[];
+    gqlArgs: GqlArg[];
+};
+export {};

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForwardedGqlArgs = void 0;
+function getForwardedGqlArgs({ fields, gqlOperation, gqlIntrospection, }) {
+    const imports = [];
+    const props = [];
+    const gqlArgs = [];
+    const skipGqlInputArgFields = fields.map((field) => String(field.name));
+    getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection).forEach((arg) => {
+        if (arg.isInputArgSubfield && skipGqlInputArgFields.includes(arg.name))
+            return;
+        if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") {
+            props.push({ name: arg.name, optional: false, type: "string" });
+        }
+        else if (arg.type === "Boolean") {
+            props.push({ name: arg.name, optional: false, type: "boolean" });
+        }
+        else if (arg.type === "Int" || arg.type === "Float") {
+            props.push({ name: arg.name, optional: false, type: "number" });
+        }
+        else if (arg.type === "JSONObject") {
+            props.push({ name: arg.name, optional: false, type: "unknown" });
+        }
+        else {
+            props.push({ 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 });
+    });
+    return {
+        imports,
+        props,
+        gqlArgs,
+    };
+}
+exports.getForwardedGqlArgs = getForwardedGqlArgs;
+function getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection) {
+    const nativeScalars = ["ID", "String", "Boolean", "Int", "Float", "DateTime", "JSONObject"];
+    // reducer is not created inline to reuse it to look into "input" arg
+    function reducer(acc, inputField) {
+        if (inputField.type.kind !== "NON_NULL" || inputField.defaultValue)
+            return acc;
+        const gqlType = inputField.type.ofType;
+        if (gqlType.kind === "INPUT_OBJECT") {
+            if (inputField.name === "input") {
+                // input-arg typically contains entity fields, so look into it
+                const typeDef = gqlIntrospection.__schema.types.find((type) => type.kind === "INPUT_OBJECT" && type.name === gqlType.name);
+                if (typeDef && typeDef.kind === "INPUT_OBJECT") {
+                    const inputArgSubfields = typeDef.inputFields.reduce(reducer, []).map((inputArgSubfield) => {
+                        return Object.assign(Object.assign({}, inputArgSubfield), { isInputArgSubfield: true });
+                    });
+                    acc.push(...inputArgSubfields);
+                }
+                else {
+                    console.warn(`IntrospectionType for ${gqlType.name} not found or no INPUT_OBJECT`);
+                }
+            }
+            else {
+                acc.push({ name: inputField.name, type: gqlType.name, isInputArgSubfield: false });
+            }
+        }
+        else if (gqlType.kind === "SCALAR") {
+            if (!nativeScalars.includes(gqlType.name)) {
+                console.warn(`Currently not supported special SCALAR of type ${gqlType.name} in arg/field ${inputField.name}`);
+            }
+            else {
+                acc.push({ name: inputField.name, type: gqlType.name, isInputArgSubfield: false });
+            }
+        }
+        else if (gqlType.kind === "ENUM") {
+            acc.push({ name: inputField.name, type: gqlType.name, isInputArgSubfield: false });
+        }
+        else if (gqlType.kind === "LIST") {
+            throw new Error(`Not supported kind ${gqlType.kind}, arg: input.${inputField.name}`);
+        }
+        return acc;
+    }
+    return gqlOperation.args.reduce(reducer, []);
+}

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

@@ -0,0 +1,43 @@
+import { type GridColDef } from "@comet/admin";
+import { type ComponentProps } from "react";
+import { type FormattedNumber } from "react-intl";
+import { type BaseColumnConfig, type ImportReference } from "../generate-command";
+type AbstractField<FieldName extends string> = {
+    field: FieldName;
+    emptyValue?: string;
+};
+type TextField<FieldName extends string> = AbstractField<FieldName> & {
+    type: "text";
+};
+type StaticText = {
+    type: "static";
+    text: string;
+};
+type FormattedNumberPropsForNumberField = Omit<ComponentProps<typeof FormattedNumber>, "value" | "children">;
+type NumberField<FieldName extends string> = AbstractField<FieldName> & FormattedNumberPropsForNumberField & {
+    type: "number";
+    decimals?: number;
+};
+type StaticSelectField<FieldName extends string> = AbstractField<FieldName> & {
+    type: "staticSelect";
+    values: Array<string | {
+        value: string | number | boolean;
+        label: string;
+    }>;
+};
+type FormattedMessage<FieldName extends string> = {
+    type: "formattedMessage";
+    message: string;
+    valueFields: Record<string, Field<FieldName>>;
+};
+type Field<FieldName extends string> = StaticText | FieldName | TextField<FieldName> | NumberField<FieldName> | StaticSelectField<FieldName> | FormattedMessage<FieldName>;
+export type GridCombinationColumnConfig<FieldName extends string> = {
+    type: "combination";
+    name: string;
+    primaryText?: Field<FieldName>;
+    secondaryText?: Field<FieldName>;
+    filterOperators?: ImportReference;
+} & BaseColumnConfig & Pick<GridColDef, "sortBy">;
+export declare const getCombinationColumnRenderCell: (column: GridCombinationColumnConfig<string>, messageIdPrefix: string) => string;
+export declare const getAllColumnFieldNames: (column: GridCombinationColumnConfig<string>) => string[];
+export {};

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

@@ -0,0 +1,151 @@
+"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.getAllColumnFieldNames = exports.getCombinationColumnRenderCell = void 0;
+const intl_1 = require("../utils/intl");
+const getTextForCellContent = (textConfig, messageIdPrefix) => {
+    if (typeof textConfig !== "string" && textConfig.type === "static") {
+        return {
+            textContent: (0, intl_1.getFormattedMessageNode)(messageIdPrefix, textConfig.text),
+        };
+    }
+    if (typeof textConfig !== "string" && textConfig.type === "formattedMessage") {
+        const variableDefinitions = [];
+        const values = Object.entries(textConfig.valueFields)
+            .map(([key, value]) => {
+            const { textContent, variableDefinitions: cellVariableDefinitions } = getTextForCellContent(value, `${messageIdPrefix}.${key}`);
+            if (cellVariableDefinitions === null || cellVariableDefinitions === void 0 ? void 0 : cellVariableDefinitions.length) {
+                variableDefinitions.push(...cellVariableDefinitions);
+            }
+            return `${key}: ${textContent}`;
+        })
+            .join(", ");
+        return {
+            textContent: (0, intl_1.getFormattedMessageNode)(messageIdPrefix, textConfig.message, `{${values}}`),
+            variableDefinitions,
+        };
+    }
+    const emptyText = typeof textConfig !== "string" && "emptyValue" in textConfig
+        ? (0, intl_1.getFormattedMessageNode)(`${messageIdPrefix}.empty`, textConfig.emptyValue)
+        : "'-'";
+    const fieldName = typeof textConfig === "string" ? textConfig : textConfig.field;
+    const rowValue = `row.${fieldName.replace(/\./g, "?.")}`;
+    const stringTextContent = `${rowValue} ?? ${emptyText}`;
+    if (typeof textConfig === "string") {
+        return {
+            textContent: stringTextContent,
+        };
+    }
+    if (textConfig.type === "number") {
+        const { type, decimals: decimalsConfigValue, field, emptyValue } = textConfig, configForFormattedNumberProps = __rest(textConfig, ["type", "decimals", "field", "emptyValue"]);
+        const hasCurrency = Boolean(textConfig.currency);
+        const hasUnit = Boolean(textConfig.unit);
+        const defaultDecimalsProp = hasCurrency && decimalsConfigValue === undefined ? 2 : decimalsConfigValue;
+        let defaultStyleProp = undefined;
+        if (hasCurrency) {
+            defaultStyleProp = '"currency"';
+        }
+        else if (hasUnit) {
+            defaultStyleProp = '"unit"';
+        }
+        const formattedNumberProps = {
+            value: `{${rowValue}}`,
+            minimumFractionDigits: typeof defaultDecimalsProp !== "undefined" ? `{${defaultDecimalsProp}}` : undefined,
+            maximumFractionDigits: typeof defaultDecimalsProp !== "undefined" ? `{${defaultDecimalsProp}}` : undefined,
+            style: typeof defaultStyleProp !== "undefined" ? defaultStyleProp : undefined,
+        };
+        Object.entries(configForFormattedNumberProps).forEach(([key, value]) => {
+            if (typeof value === "string") {
+                formattedNumberProps[key] = `"${value}"`;
+            }
+            else {
+                formattedNumberProps[key] = `{${value}}`;
+            }
+        });
+        const formattedNumberPropsString = Object.entries(formattedNumberProps)
+            .map(([key, value]) => {
+            if (typeof value === "undefined") {
+                return null;
+            }
+            return `${key}=${value}`;
+        })
+            .join(" ");
+        return {
+            textContent: `typeof ${rowValue} === "undefined" || ${rowValue} === null ? ${emptyText} : <FormattedNumber ${formattedNumberPropsString} />`,
+        };
+    }
+    if (textConfig.type === "staticSelect") {
+        const labelsVariableName = `${textConfig.field}Labels`;
+        const labelMapping = textConfig.values
+            .map((valueOption) => {
+            const value = typeof valueOption === "string" ? valueOption : valueOption.value;
+            const label = typeof valueOption === "string" ? valueOption : valueOption.label;
+            return `${value}: ${(0, intl_1.getFormattedMessageNode)(`${messageIdPrefix}.${value}`, label)}`;
+        })
+            .join(", ");
+        const labelMappingVar = `const ${labelsVariableName}: Record<string, ReactNode> = { ${labelMapping} };`;
+        const textContent = `(${rowValue} == null ? ${emptyText} : ${labelsVariableName}[` + `\`\${${rowValue}}\`` + `] ?? ${rowValue})`;
+        return {
+            textContent,
+            variableDefinitions: [labelMappingVar],
+        };
+    }
+    return {
+        textContent: stringTextContent,
+    };
+};
+const getCombinationColumnRenderCell = (column, messageIdPrefix) => {
+    const gridCellContentProps = {};
+    const allVariableDefinitions = [];
+    if (column.primaryText) {
+        const { textContent, variableDefinitions = [] } = getTextForCellContent(column.primaryText, `${messageIdPrefix}.primaryText`);
+        gridCellContentProps.primaryText = textContent;
+        allVariableDefinitions.push(...variableDefinitions);
+    }
+    if (column.secondaryText) {
+        const { textContent, variableDefinitions = [] } = getTextForCellContent(column.secondaryText, `${messageIdPrefix}.secondaryText`);
+        gridCellContentProps.secondaryText = textContent;
+        allVariableDefinitions.push(...variableDefinitions);
+    }
+    const allUniqueVariableDefinitions = Array.from(new Set(allVariableDefinitions));
+    return `({ row }) => {
+        ${allUniqueVariableDefinitions.join("\n")}
+        return <GridCellContent ${Object.entries(gridCellContentProps)
+        .map(([key, value]) => `${key}={${value}}`)
+        .join(" ")} />;
+    }`;
+};
+exports.getCombinationColumnRenderCell = getCombinationColumnRenderCell;
+const getFieldNamesFromText = (textConfig) => {
+    if (typeof textConfig === "string") {
+        return [textConfig];
+    }
+    if (textConfig.type === "static") {
+        return [];
+    }
+    if (textConfig.type === "formattedMessage") {
+        return Object.values(textConfig.valueFields).flatMap((value) => getFieldNamesFromText(value));
+    }
+    return [textConfig.field];
+};
+const getAllColumnFieldNames = (column) => {
+    const fieldNames = [];
+    if (column.primaryText) {
+        fieldNames.push(...getFieldNamesFromText(column.primaryText));
+    }
+    if (column.secondaryText) {
+        fieldNames.push(...getFieldNamesFromText(column.secondaryText));
+    }
+    return fieldNames.filter((fieldName) => fieldName !== "id");
+};
+exports.getAllColumnFieldNames = getAllColumnFieldNames;

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

@@ -0,0 +1,2 @@
+import { type IntrospectionInputObjectType, type IntrospectionInputValue, type IntrospectionQuery } from "graphql";
+export declare function findInputObjectType(input: IntrospectionInputValue, schema: IntrospectionQuery): IntrospectionInputObjectType | undefined;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findInputObjectType = void 0;
+function findInputObjectType(input, schema) {
+    let type = input.type;
+    if (type.kind == "NON_NULL") {
+        type = type.ofType;
+    }
+    if (type.kind !== "INPUT_OBJECT") {
+        throw new Error("must be INPUT_OBJECT");
+    }
+    const typeName = type.name;
+    const filterType = schema.__schema.types.find((type) => type.kind === "INPUT_OBJECT" && type.name === typeName);
+    return filterType;
+}
+exports.findInputObjectType = findInputObjectType;

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

@@ -0,0 +1,5 @@
+import { type ActionsGridColumnConfig, type GridColumnConfig } from "../generate-command";
+import { type GridCombinationColumnConfig } from "./combinationColumn";
+export declare function generateGqlFieldList({ columns, }: {
+    columns: Array<GridColumnConfig<any> | GridCombinationColumnConfig<string> | ActionsGridColumnConfig>;
+}): string;

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

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGqlFieldList = void 0;
+const object_path_1 = __importDefault(require("object-path"));
+const combinationColumn_1 = require("./combinationColumn");
+const recursiveStringify = (obj) => {
+    let ret = "";
+    let prefixField = "";
+    for (const key in obj) {
+        const valueForKey = obj[key];
+        if (typeof valueForKey === "boolean") {
+            ret += `${prefixField}${key}`;
+        }
+        else if (typeof valueForKey === "string") {
+            ret += `${prefixField}${key}${valueForKey}`;
+        }
+        else {
+            ret += `${prefixField}${key} { ${recursiveStringify(valueForKey)} }`;
+        }
+        prefixField = " ";
+    }
+    return ret;
+};
+function generateGqlFieldList({ columns, }) {
+    const fieldsObject = columns.reduce((acc, field) => {
+        if (field.type !== "actions") {
+            if (field.type === "combination") {
+                (0, combinationColumn_1.getAllColumnFieldNames)(field).map((fieldName) => {
+                    object_path_1.default.set(acc, fieldName, true);
+                });
+            }
+            else {
+                object_path_1.default.set(acc, field.name, true);
+            }
+        }
+        return acc;
+    }, {});
+    return recursiveStringify(fieldsObject);
+}
+exports.generateGqlFieldList = generateGqlFieldList;

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

@@ -0,0 +1,14 @@
+import { type IntrospectionQuery } from "graphql";
+import { type GeneratorReturn, type GridConfig } from "../generate-command";
+export type Prop = {
+    type: string;
+    optional: boolean;
+    name: string;
+    defaultValue?: string | number;
+};
+export declare function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection, }: {
+    exportName: string;
+    baseOutputFilename: string;
+    targetDirectory: string;
+    gqlIntrospection: IntrospectionQuery;
+}, config: GridConfig<any>): GeneratorReturn;