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

package/lib/commands/generate/config/transformConfig.d.ts

@@ -1 +1,7 @@
+import * as ts from "typescript";
 export declare function transformConfigFile(fileName: string, sourceText: string): string;
+export declare function collectImports(rootNode: ts.Node): Map<string, {
+    name: string;
+    import: string;
+    defaultImport?: boolean;
+}>;

package/lib/commands/generate/config/transformConfig.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformConfigFile = transformConfigFile;
+exports.collectImports = collectImports;
 const ts = __importStar(require("typescript"));
 const supportedImportPaths = [
     "[type=grid].columns.filterOperators",
@@ -60,6 +61,21 @@ function transformConfigFile(fileName, sourceText) {
     function configTransformer() {
         return (context) => {
             const visit = (node, path) => {
+                if (ts.isCallExpression(node)) {
+                    if (node.expression.getText() === "injectFormVariables") {
+                        if (!path.startsWith("[type=form].fields")) {
+                            throw new Error(`injectFormVariables can only be used in form field definitions: ${path}`);
+                        }
+                        if (node.arguments.length !== 1) {
+                            throw new Error(`injectFormVariables expects exactly one argument`);
+                        }
+                        const injectFormVariablesArg = node.arguments[0];
+                        if (!ts.isArrowFunction(injectFormVariablesArg)) {
+                            throw new Error(`injectFormVariables expects an arrow function as its argument`);
+                        }
+                        node = injectFormVariablesArg.body;
+                    }
+                }
                 if (ts.isArrowFunction(node)) {
                     if (supportedInlineCodePaths.includes(path)) {
                         let code = node.getText();
@@ -73,6 +89,9 @@ function transformConfigFile(fileName, sourceText) {
                                 return ts.factory.createObjectLiteralExpression([
                                     ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(imprt.name)),
                                     ts.factory.createPropertyAssignment("import", ts.factory.createStringLiteral(imprt.import)),
+                                    ...(imprt.defaultImport
+                                        ? [ts.factory.createPropertyAssignment("defaultImport", ts.factory.createTrue())]
+                                        : []),
                                 ]);
                             }))),
                         ], true);
@@ -193,16 +212,25 @@ function getTypePropertyFromObjectLiteral(node) {
 function collectImports(rootNode) {
     const importedIdentifiers = new Map();
     function visit(node) {
-        if (ts.isImportDeclaration(node) &&
-            node.importClause &&
-            node.importClause.namedBindings &&
-            ts.isNamedImports(node.importClause.namedBindings)) {
+        if (ts.isImportDeclaration(node) && node.importClause) {
             const moduleSpecifier = node.moduleSpecifier.text;
-            for (const element of node.importClause.namedBindings.elements) {
-                const localName = element.name.text;
-                const originalName = element.propertyName ? element.propertyName.text : localName;
+            if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                //named import
+                for (const element of node.importClause.namedBindings.elements) {
+                    const localName = element.name.text;
+                    const originalName = element.propertyName ? element.propertyName.text : localName;
+                    importedIdentifiers.set(localName, {
+                        name: originalName,
+                        import: moduleSpecifier,
+                    });
+                }
+            }
+            else if (node.importClause.name && ts.isIdentifier(node.importClause.name)) {
+                //default import
+                const localName = node.importClause.name.text;
                 importedIdentifiers.set(localName, {
-                    name: originalName,
+                    defaultImport: true,
+                    name: localName,
                     import: moduleSpecifier,
                 });
             }

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

@@ -1,12 +1,13 @@
+import { type ApolloClient } from "@apollo/client";
 import { type GridColDef } from "@comet/admin";
 import { type IconName } from "@comet/admin-icons";
-import { type BlockInterface, type FinalFormFileUploadProps } from "@comet/cms-admin";
+import { type BlockInterface, type ContentScope, type FinalFormFileUploadProps } from "@comet/cms-admin";
 import { type IconProps } from "@mui/material";
 import { type GridCellParams, type GridFilterItem, type GridFilterOperator, type GridRenderCellParams, type GridSortDirection, type GridValidRowModel } from "@mui/x-data-grid";
 import { Command } from "commander";
-import { type FieldValidator } from "final-form";
+import { type FieldValidator, type FormApi } 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,37 +61,42 @@ 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.
+     *
+     * defaults to true if rootQuery has a search argument
+     */
+    autocomplete?: boolean;
     /**
      * filter for query, passed as variable to graphql query
      */
@@ -101,24 +107,29 @@ export type FormFieldConfig<T> = (({
     loadValueQueryField: string;
     rootQuery: string;
     labelField?: string;
+    /** Whether Autocomplete or Select should be used.
+     *
+     * defaults to true if rootQuery has a search argument
+     */
+    autocomplete?: boolean;
     /**
      * filter for query, passed as variable to graphql query
      */
     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">)) & {
@@ -131,7 +142,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>[];
 };
@@ -153,8 +164,26 @@ export type FormConfig<T extends {
     mode?: "edit" | "add" | "all";
     fragmentName?: string;
     createMutation?: string;
+    /**
+     * If true, scope will be passed as prop, if false scope will be fetched from ContentScopeContext
+     * @default false
+     */
+    scopeAsProp?: boolean;
     fields: (FormFieldConfig<T> | FormLayoutConfig<T> | ComponentFormFieldConfig)[];
+    /**
+     * If true, the form will navigate to the edit page using stackSwitchApi.activatePage of the newly created item after a successful creation.
+     * @default true
+     */
+    navigateOnCreate?: boolean;
+};
+export type InjectedFormVariables = {
+    id?: string;
+    mode?: "edit" | "add";
+    client: ApolloClient<object>;
+    formApi: FormApi<unknown, Partial<unknown>>;
+    scope: ContentScope;
 };
+export declare function injectFormVariables<T>(fn: (injectedVariables: InjectedFormVariables) => T): T;
 type BaseColumnConfig = Pick<GridColDef, "headerName" | "width" | "minWidth" | "maxWidth" | "flex" | "pinned" | "disableExport"> & {
     headerInfoTooltip?: string;
     visible?: ColumnVisibleOption;
@@ -262,6 +291,11 @@ export type GridConfig<T extends {
         enabled: boolean;
         dragPreviewField?: UsableFields<T>;
     };
+    /**
+     * If true, scope will be passed as prop, if false scope will be fetched from ContentScopeContext
+     * @default false
+     */
+    scopeAsProp?: boolean;
 };
 export type GeneratorConfig<T extends {
     __typename?: string;

package/lib/commands/generate/generate-command.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommand = void 0;
 exports.isFormFieldConfig = isFormFieldConfig;
 exports.isFormLayoutConfig = isFormLayoutConfig;
+exports.injectFormVariables = injectFormVariables;
 exports.defineConfig = defineConfig;
 const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
 const load_1 = require("@graphql-tools/load");
@@ -33,6 +34,10 @@ function isFormFieldConfig(arg) {
 function isFormLayoutConfig(arg) {
     return arg.type !== undefined && ["fieldSet", "optionalNestedFields"].includes(arg.type);
 }
+function injectFormVariables(fn) {
+    // this function is only used in config but never called at runtime
+    return fn({});
+}
 function defineConfig(config) {
     return config;
 }

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

@@ -4,6 +4,7 @@ exports.findIntrospectionObjectType = findIntrospectionObjectType;
 exports.generateAsyncSelect = generateAsyncSelect;
 const generate_command_1 = require("../../generate-command");
 const findQueryType_1 = require("../../utils/findQueryType");
+const generateGqlOperation_1 = require("../../utils/generateGqlOperation");
 const isFieldOptional_1 = require("../../utils/isFieldOptional");
 const options_1 = require("../formField/options");
 const generateFields_1 = require("../generateFields");
@@ -100,21 +101,21 @@ function findIntrospectionObjectType({ config, gqlIntrospection, gqlType, }) {
     }
 }
 function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, formConfig, gqlType, namePrefix, }) {
-    var _a, _b;
+    var _a, _b, _c;
     const imports = [];
     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,
@@ -154,6 +155,16 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     else {
         formFragmentFields = [`${name}.id`, `${name}.${labelField}`];
     }
+    const rootQueryHasSearchArg = rootQueryType.args.find((arg) => arg.name === "search");
+    const useAutocomplete = (_c = config.autocomplete) !== null && _c !== void 0 ? _c : !!rootQueryHasSearchArg;
+    if (useAutocomplete) {
+        if (!rootQueryHasSearchArg) {
+            throw new Error(`Field ${String(config.name)}: Autocomplete is enabled but root query "${rootQuery}" has no search argument.`);
+        }
+        if (rootQueryHasSearchArg.type.kind !== "SCALAR" || rootQueryHasSearchArg.type.name !== "String") {
+            throw new Error(`Field ${String(config.name)}: Autocomplete is enabled but root query "${rootQuery}" has search argument that is not a string.`);
+        }
+    }
     const filterConfig = config.filter
         ? (() => {
             var _a;
@@ -267,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({
@@ -285,13 +296,19 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
         name: `GQL${queryName}QueryVariables`,
         importPath: `./${baseOutputFilename}.generated`,
     });
+    if (useAutocomplete) {
+        imports.push({ name: "AsyncAutocompleteField", importPath: "@comet/admin" });
+    }
+    else {
+        imports.push({ name: "AsyncSelectField", importPath: "@comet/admin" });
+    }
     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 = `<AsyncSelectField
+    code = `<${useAutocomplete ? "AsyncAutocompleteField" : "AsyncSelectField"}
                 ${required ? "required" : ""}
                 variant="horizontal"
                 fullWidth
@@ -300,18 +317,26 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
                 name="${nameWithPrefix}"
                 label={${fieldLabel}}
                 ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
-                loadOptions={async () => {
+                loadOptions={async (${useAutocomplete ? `search?: string` : ""}) => {
                     const { data } = await client.query<GQL${queryName}Query, GQL${queryName}QueryVariables>({
-                        query: gql\`query ${queryName}${filterConfig
-        ? `($${filterConfig.filterVarName}: ${filterConfig.filterType.typeClass}${filterConfig.filterType.required ? `!` : ``})`
-        : ``} {
-                            ${rootQuery}${filterConfig ? `(${filterConfig.filterVarName}: $${filterConfig.filterVarName})` : ``} {
-                                nodes {
-                                    id
-                                    ${labelField}
-                                }
-                            }
-                        }\`${filterConfig ? `, variables: { ${filterConfig.filterVarName}: ${filterConfig.filterVarValue} }` : ``}
+                        query: gql\`${(0, generateGqlOperation_1.generateGqlOperation)({
+        type: "query",
+        operationName: queryName,
+        rootOperation: rootQuery,
+        fields: ["nodes.id", `nodes.${labelField}`],
+        variables: [
+            useAutocomplete ? { name: "search", type: "String" } : undefined,
+            filterConfig
+                ? {
+                    name: filterConfig.filterVarName,
+                    type: filterConfig.filterType.typeClass + (filterConfig.filterType.required ? `!` : ``),
+                }
+                : undefined,
+        ].filter((v) => v !== undefined),
+    })}\`${filterConfig || useAutocomplete ? ", variables: { " : ""}
+                            ${filterConfig ? `${filterConfig.filterVarName}: ${filterConfig.filterVarValue},` : ``}
+                            ${useAutocomplete ? `search,` : ``}
+                        ${filterConfig || useAutocomplete ? " }" : ""}
                     });
                     return data.${rootQuery}.nodes;
                 }}
@@ -329,7 +354,6 @@ function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, for
     return {
         code,
         hooksCode: "",
-        formValueToGqlInputCode,
         formFragmentFields,
         gqlDocuments: {},
         imports,

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

@@ -0,0 +1,2 @@
+import { type FormConfig, type FormFieldConfig } from "../generate-command";
+export declare function flatFormFieldsFromFormConfig(config: FormConfig<any>): FormFieldConfig<any>[];

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatFormFieldsFromFormConfig = flatFormFieldsFromFormConfig;
+const generate_command_1 = require("../generate-command");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function flatFormFieldsFromFormConfig(config) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return config.fields.reduce((acc, field) => {
+        if ((0, generate_command_1.isFormLayoutConfig)(field)) {
+            // using forEach instead of acc.push(...field.fields.filter(isFormFieldConfig)) because typescript can't handle mixed typing
+            field.fields.forEach((nestedFieldConfig) => {
+                if ((0, generate_command_1.isFormFieldConfig)(nestedFieldConfig)) {
+                    acc.push(nestedFieldConfig);
+                }
+            });
+        }
+        else if ((0, generate_command_1.isFormFieldConfig)(field)) {
+            acc.push(field);
+        }
+        return acc;
+    }, []);
+}

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,