@comet/admin-generator 8.7.0-canary-20251112090955 → 8.7.0-canary-20251113072631

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

@@ -6,7 +6,7 @@ import { type GridCellParams, type GridFilterItem, type GridFilterOperator, type
 import { Command } from "commander";
 import { type FieldValidator } from "final-form";
 import { type ComponentType } from "react";
-import { type UsableFields } from "./generateGrid/usableFields";
+import { type UsableFields, type UsableFormFields } from "./generateGrid/usableFields";
 import { type ColumnVisibleOption } from "./utils/columnVisibility";
 type IconObject = Pick<IconProps, "color" | "fontSize"> & {
     name: IconName;
@@ -60,35 +60,35 @@ type AsyncSelectFilter = {
 };
 export type FormFieldConfig<T> = (({
     type: "text";
-    name: keyof T;
+    name: UsableFormFields<T>;
     multiline?: boolean;
 } & InputBaseFieldConfig) | ({
     type: "number";
-    name: keyof T;
+    name: UsableFormFields<T>;
     decimals?: number;
 } & InputBaseFieldConfig) | ({
     type: "numberRange";
-    name: keyof T;
+    name: UsableFormFields<T>;
     minValue: number;
     maxValue: number;
     disableSlider?: boolean;
 } & InputBaseFieldConfig) | {
     type: "boolean";
-    name: keyof T;
+    name: UsableFormFields<T>;
 } | ({
     type: "date";
-    name: keyof T;
+    name: UsableFormFields<T>;
 } & InputBaseFieldConfig) | ({
     type: "dateTime";
-    name: keyof T;
+    name: UsableFormFields<T>;
 } & InputBaseFieldConfig) | ({
     type: "staticSelect";
-    name: keyof T;
+    name: UsableFormFields<T>;
     values?: StaticSelectValue[];
     inputType?: "select" | "radio";
 } & Omit<InputBaseFieldConfig, "endAdornment">) | ({
     type: "asyncSelect";
-    name: keyof T;
+    name: UsableFormFields<T>;
     rootQuery: string;
     labelField?: string;
     /** Whether Autocomplete or Select should be used.
@@ -117,18 +117,18 @@ export type FormFieldConfig<T> = (({
     filter?: AsyncSelectFilter;
 } & Omit<InputBaseFieldConfig, "endAdornment">) | {
     type: "block";
-    name: keyof T;
+    name: UsableFormFields<T>;
     block: BlockInterface;
 } | ({
     type: "fileUpload";
     multiple?: false;
-    name: keyof T;
+    name: UsableFormFields<T>;
     maxFiles?: 1;
     download?: boolean;
 } & Pick<Partial<FinalFormFileUploadProps<false>>, "maxFileSize" | "readOnly" | "layout" | "accept">) | ({
     type: "fileUpload";
     multiple: true;
-    name: keyof T;
+    name: UsableFormFields<T>;
     maxFiles?: number;
     download?: boolean;
 } & Pick<Partial<FinalFormFileUploadProps<true>>, "maxFileSize" | "readOnly" | "layout" | "accept">)) & {
@@ -141,7 +141,7 @@ export type FormFieldConfig<T> = (({
 export declare function isFormFieldConfig<T>(arg: any): arg is FormFieldConfig<T>;
 type OptionalNestedFieldsConfig<T> = {
     type: "optionalNestedFields";
-    name: keyof T;
+    name: UsableFormFields<T>;
     checkboxLabel?: string;
     fields: FormFieldConfig<any>[];
 };

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

@@ -106,16 +106,16 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     const formProps = [];
     const { name, fieldLabel, startAdornment, 
     //endAdornment,
-    imports: optionsImports, } = (0, options_1.buildFormFieldOptions)({ config, formConfig, gqlIntrospection, gqlType });
+    imports: optionsImports, } = (0, options_1.buildFormFieldOptions)({ config, formConfig });
     imports.push(...optionsImports);
     const nameWithPrefix = `${namePrefix ? `${namePrefix}.` : ``}${name}`;
     const required = !(0, isFieldOptional_1.isFieldOptional)({ config, gqlIntrospection, gqlType });
     const formValueConfig = {
-        destructFromFormValues: config.type == "asyncSelectFilter" ? name : undefined,
+        fieldName: name,
+        destructFromFormValues: config.type == "asyncSelectFilter",
     };
     let finalFormConfig;
     let code = "";
-    let formValueToGqlInputCode = "";
     const { objectType, multiple } = findIntrospectionObjectType({
         config,
         gqlIntrospection,
@@ -278,14 +278,14 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     if (config.type != "asyncSelectFilter") {
         if (!multiple) {
             if (!required) {
-                formValueToGqlInputCode = `${name}: formValues.${name} ? formValues.${name}.id : null,`;
+                formValueConfig.formValueToGqlInputCode = `$fieldName ? $fieldName.id : null`;
             }
             else {
-                formValueToGqlInputCode = `${name}: formValues.${name}?.id,`;
+                formValueConfig.formValueToGqlInputCode = `$fieldName?.id`;
             }
         }
         else {
-            formValueToGqlInputCode = `${name}: formValues.${name}.map((item) => item.id),`;
+            formValueConfig.formValueToGqlInputCode = `$fieldName.map((item) => item.id)`;
         }
     }
     imports.push({
@@ -305,8 +305,8 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
     if (config.type == "asyncSelectFilter") {
         // add (in the gql schema) non existing value for virtual filter field
-        formValueConfig.typeCode = `${name}?: { id: string; ${labelField}: string };`;
-        formValueConfig.initializationCode = `${name}: data.${instanceGqlType}.${config.loadValueQueryField.replace(/\./g, "?.")}`;
+        formValueConfig.typeCode = { nullable: true, type: `{ id: string; ${labelField}: string }` };
+        formValueConfig.initializationCode = `data.${instanceGqlType}.${config.loadValueQueryField.replace(/\./g, "?.")}`;
     }
     code = `<${useAutocomplete ? "AsyncAutocompleteField" : "AsyncSelectField"}
                 ${required ? "required" : ""}
@@ -354,7 +354,6 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     return {
         code,
         hooksCode: "",
-        formValueToGqlInputCode,
         formFragmentFields,
         gqlDocuments: {},
         imports,

package/lib/commands/generate/generateForm/formField/findIntrospectionFieldType.d.ts

@@ -0,0 +1,6 @@
+import { type IntrospectionQuery } from "graphql";
+export declare function findIntrospectionFieldType({ name, gqlType, gqlIntrospection, }: {
+    name: string;
+    gqlType: string;
+    gqlIntrospection: IntrospectionQuery;
+}): import("graphql").IntrospectionNamedTypeRef<import("graphql").IntrospectionOutputType> | import("graphql").IntrospectionListTypeRef<import("graphql").IntrospectionOutputTypeRef> | undefined;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIntrospectionFieldType = findIntrospectionFieldType;
+function findIntrospectionFieldType({ name, gqlType, gqlIntrospection, }) {
+    let introspectionFieldType;
+    for (const namePart of name.split(".")) {
+        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 === namePart);
+        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)
+            gqlType = introspectionFieldType.name;
+        }
+    }
+    return introspectionFieldType;
+}

package/lib/commands/generate/generateForm/formField/options.d.ts

@@ -1,4 +1,3 @@
-import { type IntrospectionQuery } from "graphql";
 import { type FormConfig, type FormFieldConfig } from "../../generate-command";
 import { type Imports } from "../../utils/generateImportsCode";
 type AdornmentData = {
@@ -11,11 +10,9 @@ type AdornmentData = {
 /**
  * Helper function that builds various options needed for generating form fields.
  */
-export declare function buildFormFieldOptions({ config, formConfig, gqlIntrospection, gqlType, }: {
+export declare function buildFormFieldOptions({ config, formConfig, }: {
     config: FormFieldConfig<any>;
     formConfig: FormConfig<any>;
-    gqlIntrospection: IntrospectionQuery;
-    gqlType: string;
 }): {
     name: string;
     formattedMessageRootId: any;
@@ -23,6 +20,5 @@ export declare function buildFormFieldOptions({ config, formConfig, gqlIntrospec
     startAdornment: AdornmentData;
     endAdornment: AdornmentData;
     imports: Imports;
-    introspectionFieldType: import("graphql").IntrospectionNamedTypeRef<import("graphql").IntrospectionOutputType> | import("graphql").IntrospectionListTypeRef<import("graphql").IntrospectionOutputTypeRef> | undefined;
 };
 export {};

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

@@ -51,22 +51,13 @@ const buildAdornmentData = ({ adornmentData }) => {
 /**
  * Helper function that builds various options needed for generating form fields.
  */
-function buildFormFieldOptions({ config, formConfig, gqlIntrospection, gqlType, }) {
+function buildFormFieldOptions({ config, formConfig, }) {
     var _a;
     const rootGqlType = formConfig.gqlType;
     const name = String(config.name);
     const label = (_a = config.label) !== null && _a !== void 0 ? _a : (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(name);
     const formattedMessageRootId = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
     const fieldLabel = `<FormattedMessage id="${formattedMessageRootId}.${name}" defaultMessage="${label}" />`;
-    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);
-    const introspectionFieldType = introspectionField
-        ? introspectionField.type.kind === "NON_NULL"
-            ? introspectionField.type.ofType
-            : introspectionField.type
-        : undefined;
     const imports = [];
     let startAdornment = { adornmentString: "" };
     let endAdornment = { adornmentString: "" };
@@ -86,5 +77,5 @@ function buildFormFieldOptions({ config, formConfig, gqlIntrospection, gqlType,
             imports.push(endAdornment.adornmentImport);
         }
     }
-    return { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports, introspectionFieldType };
+    return { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports };
 }

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

@@ -14,7 +14,6 @@ function generateComponentFormField({ config }) {
         formProps: [],
         hooksCode: "",
         formFragmentFields: [],
-        formValueToGqlInputCode: "",
         formValuesConfig: [],
         finalFormConfig: undefined,
         code,

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

@@ -6,14 +6,19 @@ export type GenerateFieldsReturn = GeneratorReturn & {
     imports: Imports;
     hooksCode: string;
     formFragmentFields: string[];
-    formValueToGqlInputCode: string;
     formProps: Prop[];
     formValuesConfig: {
-        omitFromFragmentType?: string;
-        destructFromFormValues?: string;
-        typeCode?: string;
+        fieldName: string;
+        omitFromFragmentType?: boolean;
+        destructFromFormValues?: boolean;
+        typeCode?: {
+            nullable: boolean;
+            type: string;
+        };
         initializationCode?: string;
         defaultInitializationCode?: string;
+        formValueToGqlInputCode?: string;
+        wrapFormValueToGqlInputCode?: string;
     }[];
     finalFormConfig?: {
         subscription?: {

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

@@ -22,7 +22,6 @@ function findFieldByName(name, fields) {
 function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFragmentName, formConfig, gqlType, namePrefix, }) {
     const gqlDocuments = {};
     let hooksCode = "";
-    let formValueToGqlInputCode = "";
     const formFragmentFields = [];
     const imports = [];
     const formProps = [];
@@ -68,7 +67,6 @@ function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFrag
         imports.push(...generated.imports);
         formProps.push(...generated.formProps);
         hooksCode += generated.hooksCode;
-        formValueToGqlInputCode += generated.formValueToGqlInputCode;
         formFragmentFields.push(...generated.formFragmentFields);
         formValuesConfig.push(...generated.formValuesConfig);
         finalFormConfig.subscription = Object.assign(Object.assign({}, finalFormConfig.subscription), (_a = generated.finalFormConfig) === null || _a === void 0 ? void 0 : _a.subscription);
@@ -79,7 +77,6 @@ function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFrag
     return {
         code,
         hooksCode,
-        formValueToGqlInputCode,
         formFragmentFields,
         gqlDocuments,
         imports,

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

@@ -288,7 +288,7 @@ config) {
 
     ${customFilterByFragment}
 
-    ${(0, generateFormValues_1.generateFormValuesType)({ config, formValuesConfig, filterByFragmentType })}
+    ${(0, generateFormValues_1.generateFormValuesType)({ formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType })}
 
     ${formPropsTypeCode}
 
@@ -308,7 +308,7 @@ config) {
         `
         : ""}
 
-        ${(0, generateFormValues_1.generateInitialValues)({ config, formValuesConfig, filterByFragmentType })}
+        ${(0, generateFormValues_1.generateInitialValues)({ mode, formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType })}
 
 
         ${editMode
@@ -326,9 +326,13 @@ config) {
         `
         : ""}
 
-        const handleSubmit = async (${(0, generateFormValues_1.generateDestructFormValueForInput)({ formValuesConfig })}: FormValues, form: FormApi<FormValues>${addMode ? `, event: FinalFormSubmitEvent` : ""}) => {
+        const handleSubmit = async (${(0, generateFormValues_1.generateDestructFormValueForInput)({
+        formValuesConfig,
+        gqlIntrospection,
+        gqlType,
+    })}: FormValues, form: FormApi<FormValues>${addMode ? `, event: FinalFormSubmitEvent` : ""}) => {
             ${editMode ? `if (await saveConflict.checkForConflicts()) throw new Error("Conflicts detected");` : ""}
-            ${(0, generateFormValues_1.generateFormValuesToGqlInput)({ generatedFields })}
+            ${(0, generateFormValues_1.generateFormValuesToGqlInput)({ formValuesConfig, gqlIntrospection, gqlType })}
 
             ${mode == "all" ? `if (mode === "edit") {` : ""}
                 ${editMode

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

@@ -6,6 +6,7 @@ const convertConfigImport_1 = require("../utils/convertConfigImport");
 const isFieldOptional_1 = require("../utils/isFieldOptional");
 const runtimeTypeGuards_1 = require("../utils/runtimeTypeGuards");
 const generateAsyncSelect_1 = require("./asyncSelect/generateAsyncSelect");
+const findIntrospectionFieldType_1 = require("./formField/findIntrospectionFieldType");
 const options_1 = require("./formField/options");
 function generateFormField({ gqlIntrospection, baseOutputFilename, config, formConfig, gqlType, namePrefix, }) {
     if (config.type == "asyncSelect" || config.type == "asyncSelectFilter") {
@@ -13,9 +14,9 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
     }
     const imports = [];
     const formProps = [];
-    const { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports: optionsImports, } = (0, options_1.buildFormFieldOptions)({ config, formConfig, gqlType, gqlIntrospection });
+    const { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports: optionsImports, } = (0, options_1.buildFormFieldOptions)({ config, formConfig });
     imports.push(...optionsImports);
-    let { introspectionFieldType } = (0, options_1.buildFormFieldOptions)({ config, formConfig, gqlType, gqlIntrospection });
+    let introspectionFieldType = (0, findIntrospectionFieldType_1.findIntrospectionFieldType)({ name, gqlIntrospection, gqlType });
     const nameWithPrefix = `${namePrefix ? `${namePrefix}.` : ``}${name}`;
     const rootGqlType = formConfig.gqlType;
     const dataRootName = rootGqlType[0].toLowerCase() + rootGqlType.substring(1); // TODO should probably be deteced via query
@@ -24,7 +25,9 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
     const endAdornmentWithLockIconProp = `endAdornment={<InputAdornment position="end"><Lock /></InputAdornment>}`;
     const readOnlyProps = `readOnly disabled`;
     const readOnlyPropsWithLock = `${readOnlyProps} ${endAdornmentWithLockIconProp}`;
-    let formValuesConfig = [{}]; // FormFields should only contain one entry
+    const formValueConfig = {
+        fieldName: nameWithPrefix,
+    };
     const gqlDocuments = {};
     const hooksCode = "";
     let finalFormConfig;
@@ -40,7 +43,6 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
         }
     }
     let code = "";
-    let formValueToGqlInputCode = "";
     let formFragmentFields = [name];
     if (config.type == "text") {
         const TextInputComponent = config.multiline ? "TextAreaField" : "TextField";
@@ -62,7 +64,7 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
             ${validateCode}
         />`;
         if (!required && !config.readOnly) {
-            formValueToGqlInputCode = `${name}: formValues.${name} ?? null,`;
+            formValueConfig.formValueToGqlInputCode = `$fieldName ?? null`;
         }
     }
     else if (config.type == "number") {
@@ -85,22 +87,21 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
                 ${validateCode}
             />`;
         //TODO MUI suggest not using type=number https://mui.com/material-ui/react-text-field/#type-quot-number-quot
-        let assignment = `parseFloat(formValues.${nameWithPrefix})`;
+        let assignment = `parseFloat($fieldName)`;
         if ((0, isFieldOptional_1.isFieldOptional)({ config, gqlIntrospection: gqlIntrospection, gqlType: gqlType })) {
-            assignment = `formValues.${nameWithPrefix} ? ${assignment} : null`;
+            assignment = `$fieldName ? ${assignment} : null`;
         }
-        formValueToGqlInputCode = `${name}: ${assignment},`;
+        formValueConfig.formValueToGqlInputCode = `${assignment}`;
         let initializationAssignment = `String(data.${dataRootName}.${nameWithPrefix})`;
         if (!required) {
             initializationAssignment = `data.${dataRootName}.${nameWithPrefix} ? ${initializationAssignment} : undefined`;
         }
-        formValuesConfig = [
-            {
-                omitFromFragmentType: name,
-                typeCode: `${name}${!required ? `?` : ``}: string;`,
-                initializationCode: `${name}: ${initializationAssignment}`,
-            },
-        ];
+        formValueConfig.omitFromFragmentType = true;
+        formValueConfig.typeCode = {
+            nullable: !required,
+            type: "string",
+        };
+        formValueConfig.initializationCode = `${initializationAssignment}`;
     }
     else if (config.type === "numberRange") {
         code = `
@@ -140,11 +141,7 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
             : ""}
                         ${validateCode}
                     />`;
-        formValuesConfig = [
-            {
-                defaultInitializationCode: `${name}: false`,
-            },
-        ];
+        formValueConfig.defaultInitializationCode = `false`;
     }
     else if (config.type == "date") {
         imports.push({
@@ -169,7 +166,7 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
                 ${validateCode}
             />`;
         if (!required && !config.readOnly) {
-            formValueToGqlInputCode = `${name}: formValues.${name} ?? null,`;
+            formValueConfig.formValueToGqlInputCode = `$fieldName ?? null`;
         }
     }
     else if (config.type == "dateTime") {
@@ -193,31 +190,25 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
             : ""}
                 ${validateCode}
             />`;
-        formValuesConfig = [
-            {
-                initializationCode: `${name}: data.${dataRootName}.${nameWithPrefix} ? new Date(data.${dataRootName}.${nameWithPrefix}) : undefined`,
-                omitFromFragmentType: name,
-                typeCode: `${name}${!required ? "?" : ""}: Date${!required ? " | null" : ""};`,
-            },
-        ];
+        formValueConfig.initializationCode = `data.${dataRootName}.${nameWithPrefix} ? new Date(data.${dataRootName}.${nameWithPrefix}) : undefined`;
+        formValueConfig.omitFromFragmentType = true;
+        formValueConfig.typeCode = {
+            nullable: !required,
+            type: `Date${!required ? " | null" : ""}`,
+        };
         if (!config.readOnly) {
-            formValueToGqlInputCode = required
-                ? `${name}: formValues.${name}.toISOString(),`
-                : `${name}: formValues.${name} ? formValues.${name}.toISOString() : null,`;
+            formValueConfig.formValueToGqlInputCode = required ? `$fieldName.toISOString()` : `$fieldName ? $fieldName.toISOString() : null`;
         }
     }
     else if (config.type == "block") {
         code = `<Field name="${nameWithPrefix}" isEqual={isEqual} label={${fieldLabel}} variant="horizontal" fullWidth>
             {createFinalFormBlock(rootBlocks.${String(config.name)})}
         </Field>`;
-        formValueToGqlInputCode = `${name}: rootBlocks.${name}.state2Output(formValues.${nameWithPrefix}),`;
-        formValuesConfig = [
-            {
-                typeCode: `${name}: BlockState<typeof rootBlocks.${name}>;`,
-                initializationCode: `${name}: rootBlocks.${name}.input2State(data.${dataRootName}.${nameWithPrefix})`,
-                defaultInitializationCode: `${name}: rootBlocks.${name}.defaultValues()`,
-            },
-        ];
+        formValueConfig.formValueToGqlInputCode = `rootBlocks.${name}.state2Output($fieldName)`;
+        formValueConfig.omitFromFragmentType = true;
+        formValueConfig.typeCode = { nullable: false, type: `BlockState<typeof rootBlocks.${name}>` };
+        formValueConfig.initializationCode = `rootBlocks.${name}.input2State(data.${dataRootName}.${nameWithPrefix})`;
+        formValueConfig.defaultInitializationCode = `rootBlocks.${name}.defaultValues()`;
     }
     else if (config.type === "fileUpload") {
         const multiple = config.multiple || (typeof config.maxFiles === "number" && config.maxFiles > 1);
@@ -231,10 +222,10 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
             ${config.accept ? `accept="${config.accept}"` : ""}
         />`;
         if (multiple) {
-            formValueToGqlInputCode = `${name}: formValues.${name}?.map(({ id }) => id),`;
+            formValueConfig.formValueToGqlInputCode = `$fieldName?.map(({ id }) => id)`;
         }
         else {
-            formValueToGqlInputCode = `${name}: formValues.${name} ? formValues.${name}.id : null,`;
+            formValueConfig.formValueToGqlInputCode = `$fieldName ? $fieldName.id : null`;
         }
         formFragmentFields = [`${name}...${config.download ? "FinalFormFileUploadDownloadable" : "FinalFormFileUpload"}`];
     }
@@ -336,12 +327,11 @@ function generateFormField({ gqlIntrospection, baseOutputFilename, config, formC
     return {
         code,
         hooksCode,
-        formValueToGqlInputCode,
         formFragmentFields,
         gqlDocuments,
         imports,
         formProps,
-        formValuesConfig,
+        formValuesConfig: [formValueConfig],
         finalFormConfig,
     };
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFormLayout = generateFormLayout;
 const camelCaseToHumanReadable_1 = require("../utils/camelCaseToHumanReadable");
+const findIntrospectionFieldType_1 = require("./formField/findIntrospectionFieldType");
 const generateFields_1 = require("./generateFields");
 function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, formFragmentName, formConfig, gqlType, namePrefix, }) {
     var _a, _b, _c, _d, _e;
@@ -10,7 +11,6 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
     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 = [];
@@ -29,7 +29,6 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
             namePrefix,
         });
         hooksCode += generatedFields.hooksCode;
-        formValueToGqlInputCode += generatedFields.formValueToGqlInputCode;
         formFragmentFields.push(...generatedFields.formFragmentFields);
         for (const name in generatedFields.gqlDocuments) {
             gqlDocuments[name] = generatedFields.gqlDocuments[name];
@@ -66,16 +65,10 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
     }
     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")
+        const introspectionFieldType = (0, findIntrospectionFieldType_1.findIntrospectionFieldType)({ name, gqlType, gqlIntrospection });
+        if (!introspectionFieldType)
+            throw new Error(`field ${name} in gql introspection type ${gqlType} not found`);
+        if (introspectionFieldType.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)({
@@ -84,7 +77,7 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
             fields: config.fields,
             formFragmentName,
             formConfig,
-            gqlType: introspectionField.type.name,
+            gqlType: introspectionFieldType.name,
             namePrefix: name,
         });
         hooksCode += generatedFields.hooksCode;
@@ -93,39 +86,26 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
             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);
+        formValuesConfig.push(...generatedFields.formValuesConfig);
+        // first field is the "enabled" checkbox
+        formValuesConfig.push({
+            fieldName: `${name}Enabled`,
+            omitFromFragmentType: false,
+            destructFromFormValues: true,
+            typeCode: {
+                nullable: false,
+                type: "boolean",
+            },
+            initializationCode: `!!data.${dataRootName}.${name}`,
+        });
+        // second field is the nested object, which is not a final-form field itself
+        formValuesConfig.push({
+            fieldName: `${name}`,
+            wrapFormValueToGqlInputCode: `${name.split(".").pop()}Enabled && $fieldName ? $inner : null`,
+        });
         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"
@@ -155,7 +135,6 @@ function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, form
     return {
         code,
         hooksCode,
-        formValueToGqlInputCode,
         formFragmentFields,
         gqlDocuments,
         imports,

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

@@ -1,18 +1,39 @@
-import { type FormConfig } from "../generate-command";
+import { type IntrospectionQuery } from "graphql";
 import { type GenerateFieldsReturn } from "./generateFields";
-export declare function generateFormValuesType({ config, formValuesConfig, filterByFragmentType, }: {
-    config: FormConfig<any>;
+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({ config, formValuesConfig, filterByFragmentType, }: {
-    config: FormConfig<any>;
+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 }: {
+export declare function generateDestructFormValueForInput({ formValuesConfig, gqlIntrospection, gqlType, }: {
     formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
 }): string;
-export declare function generateFormValuesToGqlInput({ generatedFields }: {
-    generatedFields: GenerateFieldsReturn;
+export declare function generateFormValuesToGqlInput({ formValuesConfig, gqlIntrospection, gqlType, }: {
+    formValuesConfig: GenerateFieldsReturn["formValuesConfig"];
+    gqlIntrospection: IntrospectionQuery;
+    gqlType: string;
 }): string;
+export {};

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

@@ -1,77 +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;
-const flatFormFieldsFromFormConfig_1 = require("./flatFormFieldsFromFormConfig");
-function generateFormValuesType({ config, formValuesConfig, filterByFragmentType, }) {
-    const formFields = (0, flatFormFieldsFromFormConfig_1.flatFormFieldsFromFormConfig)(config);
-    const rootBlockFields = formFields
-        .filter((field) => field.type == "block")
-        .map((field) => {
-        // map is for ts to infer block type correctly
-        if (field.type !== "block")
-            throw new Error("Field is not a block field");
-        return field;
-    });
-    return `type FormValues = ${formValuesConfig.filter((config) => !!config.omitFromFragmentType).length > 0 || rootBlockFields.length > 0
-        ? `Omit<${filterByFragmentType}, ${[
-            ...(rootBlockFields.length > 0 ? ["keyof typeof rootBlocks"] : []),
-            ...formValuesConfig.filter((config) => !!config.omitFromFragmentType).map((config) => `"${config.omitFromFragmentType}"`),
-        ].join(" | ")}>`
-        : `${filterByFragmentType}`} ${formValuesConfig.filter((config) => !!config.typeCode).length > 0
-        ? `& {
-                ${formValuesConfig
-            .filter((config) => !!config.typeCode)
-            .map((config) => config.typeCode)
-            .join("\n")}
-            }`
-        : ""};`;
+// 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 generateInitialValues({ config, formValuesConfig, filterByFragmentType, }) {
+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;
-    const gqlType = config.gqlType;
+    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 mode = (_a = config.mode) !== null && _a !== void 0 ? _a : "all";
     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}),
-                ${formValuesConfig
-            .filter((config) => !!config.initializationCode)
-            .map((config) => config.initializationCode)
-            .join(",\n")}
+                ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "initializationCode")}
             }
             : {
-                ${formValuesConfig
-            .filter((config) => !!config.defaultInitializationCode)
-            .map((config) => config.defaultInitializationCode)
-            .join(",\n")}
+                ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "defaultInitializationCode")}
             }
         , [data]);`;
     }
     else {
         return `const initialValues = {
-            ${formValuesConfig
-            .filter((config) => !!config.defaultInitializationCode)
-            .map((config) => config.defaultInitializationCode)
-            .join(",\n")}
+            ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "defaultInitializationCode")}
         };`;
     }
 }
-function generateDestructFormValueForInput({ formValuesConfig }) {
-    return formValuesConfig.filter((config) => !!config.destructFromFormValues).length
-        ? `{ ${formValuesConfig
-            .filter((config) => !!config.destructFromFormValues)
-            .map((config) => config.destructFromFormValues)
-            .join(", ")}, ...formValues }`
-        : `formValues`;
+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({ generatedFields }) {
-    return `const output = {
-        ...formValues,
-        ${generatedFields.formValueToGqlInputCode}
-    };`;
+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/getForwardedGqlArgs.js

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getForwardedGqlArgs = getForwardedGqlArgs;
 function getForwardedGqlArgs({ fields, gqlOperation, gqlIntrospection, }) {
     const ret = [];
-    const skipGqlInputArgFields = fields.map((field) => String(field.name));
     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") {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comet/admin-generator",
-  "version": "8.7.0-canary-20251112090955",
+  "version": "8.7.0-canary-20251113072631",
   "description": "Comet Admin Generator CLI tool",
   "repository": {
     "directory": "packages/admin/admin-generator",
@@ -47,10 +47,10 @@
     "rimraf": "^6.0.1",
     "ts-jest": "^29.4.0",
     "typescript": "5.8.3",
-    "@comet/admin": "8.7.0-canary-20251112090955",
-    "@comet/admin-icons": "8.7.0-canary-20251112090955",
-    "@comet/cms-admin": "8.7.0-canary-20251112090955",
-    "@comet/eslint-config": "8.7.0-canary-20251112090955"
+    "@comet/admin": "8.7.0-canary-20251113072631",
+    "@comet/admin-icons": "8.7.0-canary-20251113072631",
+    "@comet/cms-admin": "8.7.0-canary-20251113072631",
+    "@comet/eslint-config": "8.7.0-canary-20251113072631"
   },
   "engines": {
     "node": ">=22.0.0"