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

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

@@ -1,364 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-function gqlScalarToTypescriptType(scalarName) {
-    if (scalarName === "String" || scalarName === "ID" || scalarName === "DateTime" || scalarName === "LocalDate" || scalarName === "Date") {
-        return "string";
-    }
-    else if (scalarName === "Boolean") {
-        return "boolean";
-    }
-    else if (scalarName === "Int" || scalarName === "Float") {
-        return "number";
-    }
-    else if (scalarName === "JSONObject") {
-        return "unknown";
-    }
-    else {
-        return "unknown";
-    }
-}
-function buildTypeInfo(arg, gqlIntrospection) {
-    let typeKind = undefined;
-    let typeClass = "unknown";
-    let required = false;
-    let type = arg.type;
-    let inputType = undefined;
-    if (type.kind === "NON_NULL") {
-        required = true;
-        type = type.ofType;
-    }
-    if (type.kind === "INPUT_OBJECT") {
-        typeClass = type.name;
-        typeKind = type.kind;
-        inputType = gqlIntrospection.__schema.types.find((type) => type.name === typeClass);
-    }
-    else if (type.kind === "ENUM") {
-        typeClass = type.name;
-        typeKind = type.kind;
-    }
-    else if (type.kind === "SCALAR") {
-        typeClass = type.name;
-        typeKind = type.kind;
-    }
-    else {
-        throw new Error(`getTypeInfo: Resolving kind ${type.kind} currently not supported.`);
-    }
-    return {
-        required,
-        typeKind,
-        typeClass,
-        inputType,
-    };
-}
-/**
- * Helper that returns the introspection object type for a given form field config, supporting the special case for asyncSelectFilter
- */
-function findIntrospectionObjectType({ config, gqlIntrospection, gqlType, }) {
-    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`);
-    function findIntrospectionField(introspectionObject, name) {
-        const introspectionField = introspectionObject.fields.find((field) => field.name === name);
-        if (!introspectionField)
-            throw new Error(`didn't find field ${name} in gql introspection type ${gqlType}`);
-        let introspectionFieldType = introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type;
-        const multiple = (introspectionFieldType === null || introspectionFieldType === void 0 ? void 0 : introspectionFieldType.kind) === "LIST";
-        if ((introspectionFieldType === null || introspectionFieldType === void 0 ? void 0 : introspectionFieldType.kind) === "LIST") {
-            introspectionFieldType =
-                introspectionFieldType.ofType.kind === "NON_NULL" ? introspectionFieldType.ofType.ofType : introspectionFieldType.ofType;
-        }
-        if (introspectionFieldType.kind !== "OBJECT")
-            throw new Error(`asyncSelect only supports OBJECT types`);
-        const objectType = gqlIntrospection.__schema.types.find((t) => t.kind === "OBJECT" && t.name === introspectionFieldType.name);
-        if (!objectType)
-            throw new Error(`Object type ${introspectionFieldType.name} not found for field ${name}`);
-        return { multiple, objectType };
-    }
-    if (config.type === "asyncSelectFilter") {
-        //for a filter select the field is "virtual", and it's ObjectType is defined by the path in config.loadValueQueryField
-        return {
-            multiple: false,
-            objectType: config.loadValueQueryField.split(".").reduce((acc, fieldName) => {
-                const introspectionField = findIntrospectionField(acc, fieldName);
-                if (introspectionField.multiple)
-                    throw new Error(`asyncSelectFilter does not support list fields in loadValueQueryField`);
-                return introspectionField.objectType;
-            }, introspectionObject),
-        };
-    }
-    else {
-        //for a standard select we just find the field directly (no nested path to follow, name can be only one level deep)
-        return findIntrospectionField(introspectionObject, name);
-    }
-}
-function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, formConfig, gqlType, namePrefix, }) {
-    var _a, _b, _c;
-    const imports = [];
-    const formProps = [];
-    const { name, fieldLabel, startAdornment, 
-    //endAdornment,
-    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 = {
-        fieldName: name,
-        destructFromFormValues: config.type == "asyncSelectFilter",
-    };
-    let finalFormConfig;
-    let code = "";
-    const { objectType, multiple } = findIntrospectionObjectType({
-        config,
-        gqlIntrospection,
-        gqlType,
-    });
-    //find labelField: 1. as configured
-    let labelField = config.labelField;
-    //find labelField: 2. common names (name or title)
-    if (!labelField) {
-        labelField = (_a = objectType.fields.find((field) => {
-            let type = field.type;
-            if (type.kind == "NON_NULL")
-                type = type.ofType;
-            if ((field.name == "name" || field.name == "title") && type.kind == "SCALAR" && type.name == "String") {
-                return true;
-            }
-        })) === null || _a === void 0 ? void 0 : _a.name;
-    }
-    //find labelField: 3. first string field
-    if (!labelField) {
-        labelField = (_b = objectType.fields.find((field) => {
-            let type = field.type;
-            if (type.kind == "NON_NULL")
-                type = type.ofType;
-            if (field.type.kind == "SCALAR" && field.type.name == "String") {
-                return true;
-            }
-        })) === null || _b === void 0 ? void 0 : _b.name;
-    }
-    const rootQuery = config.rootQuery; //TODO we should infer a default value from the gql schema
-    const queryName = `${rootQuery[0].toUpperCase() + rootQuery.substring(1)}Select`;
-    const rootQueryType = (0, findQueryType_1.findQueryTypeOrThrow)(rootQuery, gqlIntrospection);
-    let formFragmentFields;
-    if (config.type == "asyncSelectFilter") {
-        formFragmentFields = [`${config.loadValueQueryField}.id`, `${config.loadValueQueryField}.${labelField}`];
-    }
-    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;
-            let filterField;
-            let rootQueryArg = config.filter.rootQueryArg;
-            let filterVar = "";
-            if (config.filter.type === "field") {
-                filterField = (0, generateFields_1.findFieldByName)(config.filter.formFieldName, formConfig.fields);
-                if (!filterField) {
-                    throw new Error(`Field ${String(config.name)}: No field with name "${config.filter.formFieldName}" referenced as filter.formFieldName found in form-config.`);
-                }
-                if (!(0, generate_command_1.isFormFieldConfig)(filterField)) {
-                    throw new Error(`Field ${String(config.name)}: Field with name "${config.filter.formFieldName}" referenced as filter.formFieldName is no FormField.`);
-                }
-                filterVar = `values.${filterField.type === "asyncSelect" || filterField.type === "asyncSelectFilter" ? `${String(filterField.name)}?.id` : String(filterField.name)}`;
-                if (!rootQueryArg) {
-                    rootQueryArg = config.filter.formFieldName;
-                }
-            }
-            else if (config.filter.type === "formProp") {
-                filterVar = config.filter.propName;
-                if (!rootQueryArg) {
-                    rootQueryArg = config.filter.propName;
-                }
-            }
-            else {
-                throw new Error("unsupported filter type");
-            }
-            // try to find arg used to filter by checking names of root-arg and filter-arg-fields
-            const rootArgForName = rootQueryType.args.find((arg) => arg.name === rootQueryArg);
-            let filterType = rootArgForName ? buildTypeInfo(rootArgForName, gqlIntrospection) : undefined;
-            let filterVarName = undefined;
-            let filterVarValue = undefined;
-            let filterVarType = "unknown";
-            if (filterType) {
-                // there is a query root arg with same name, filter using it
-                filterVarName = rootQueryArg;
-                filterVarValue = filterVar;
-                if (filterType.typeKind === "INPUT_OBJECT" || filterType.typeKind === "ENUM") {
-                    filterVarType = `GQL${filterType.typeClass}`;
-                    imports.push({
-                        name: filterVarType,
-                        importPath: "@src/graphql.generated",
-                    });
-                }
-                else if (filterType.typeKind === "SCALAR") {
-                    filterVarType = gqlScalarToTypescriptType(filterType.typeClass);
-                }
-            }
-            else {
-                // no root-arg with same name, check filter-arg-fields
-                const rootArgFilter = rootQueryType.args.find((arg) => arg.name === "filter");
-                filterType = rootArgFilter ? buildTypeInfo(rootArgFilter, gqlIntrospection) : undefined;
-                if (filterType) {
-                    filterVarName = "filter";
-                    filterVarValue = `{ ${rootQueryArg}: { equal: ${filterVar} } }`;
-                    // get type of field.equal in filter-arg used for filtering
-                    if (((_a = filterType.inputType) === null || _a === void 0 ? void 0 : _a.kind) !== "INPUT_OBJECT") {
-                        throw new Error(`Field ${String(config.name)}: Type of filter is no object-type.`);
-                    }
-                    const nestedFilterInput = filterType.inputType.inputFields.find((inputField) => inputField.name === rootQueryArg);
-                    if (!nestedFilterInput) {
-                        throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg} does not exist`);
-                    }
-                    const gqlFilterInputType = buildTypeInfo(nestedFilterInput, gqlIntrospection);
-                    if (!(gqlFilterInputType === null || gqlFilterInputType === void 0 ? void 0 : gqlFilterInputType.inputType) || gqlFilterInputType.inputType.kind !== "INPUT_OBJECT") {
-                        throw new Error(`Field ${String(config.name)}: Type of filter.${rootQueryArg} is no object-type, but needs to be e.g. StringFilter-type.`);
-                    }
-                    const gqlFilterEqualInputType = gqlFilterInputType.inputType.inputFields.find((inputField) => inputField.name === "equal");
-                    if (!gqlFilterEqualInputType) {
-                        throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg}.equal does not exist`);
-                    }
-                    const equalFieldType = buildTypeInfo(gqlFilterEqualInputType, gqlIntrospection);
-                    if (!equalFieldType) {
-                        throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg}.equal does not exist but is required for filtering.`);
-                    }
-                    if (equalFieldType.typeKind === "INPUT_OBJECT" || equalFieldType.typeKind === "ENUM") {
-                        filterVarType = `GQL${equalFieldType.typeClass}`;
-                        imports.push({
-                            name: filterVarType,
-                            importPath: "@src/graphql.generated",
-                        });
-                    }
-                    else if (equalFieldType.typeKind === "SCALAR") {
-                        filterVarType = gqlScalarToTypescriptType(equalFieldType.typeClass);
-                    }
-                }
-                else {
-                    throw new Error(`Neither filter-prop nor root-prop with name: ${rootQueryArg} for asyncSelect-query not found. Consider setting filterField.gqlVarName explicitly.`);
-                }
-            }
-            if (config.filter.type === "formProp") {
-                formProps.push({
-                    name: config.filter.propName,
-                    optional: false,
-                    type: filterVarType,
-                });
-            }
-            return {
-                filterField,
-                filterType,
-                filterVarName,
-                filterVarValue,
-            };
-        })()
-        : undefined;
-    if (filterConfig) {
-        imports.push({ name: "OnChangeField", importPath: "@comet/admin" });
-        finalFormConfig = { subscription: { values: true }, renderProps: { values: true, form: true } };
-    }
-    if (config.type != "asyncSelectFilter") {
-        if (!multiple) {
-            if (!required) {
-                formValueConfig.formValueToGqlInputCode = `$fieldName ? $fieldName.id : null`;
-            }
-            else {
-                formValueConfig.formValueToGqlInputCode = `$fieldName?.id`;
-            }
-        }
-        else {
-            formValueConfig.formValueToGqlInputCode = `$fieldName.map((item) => item.id)`;
-        }
-    }
-    imports.push({
-        name: `GQL${queryName}Query`,
-        importPath: `./${baseOutputFilename}.generated`,
-    });
-    imports.push({
-        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 = { nullable: true, type: `{ id: string; ${labelField}: string }` };
-        formValueConfig.initializationCode = `data.${instanceGqlType}.${config.loadValueQueryField.replace(/\./g, "?.")}`;
-    }
-    code = `<${useAutocomplete ? "AsyncAutocompleteField" : "AsyncSelectField"}
-                ${required ? "required" : ""}
-                variant="horizontal"
-                fullWidth
-                ${config.readOnly ? "readOnly disabled" : ""}
-                ${multiple ? "multiple" : ""}
-                name="${nameWithPrefix}"
-                label={${fieldLabel}}
-                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
-                loadOptions={async (${useAutocomplete ? `search?: string` : ""}) => {
-                    const { data } = await client.query<GQL${queryName}Query, GQL${queryName}QueryVariables>({
-                        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;
-                }}
-                getOptionLabel={(option) => option.${labelField}}
-                ${(filterConfig === null || filterConfig === void 0 ? void 0 : filterConfig.filterField) ? `disabled={!values?.${String(filterConfig.filterField.name)}}` : ``}
-            />${(filterConfig === null || filterConfig === void 0 ? void 0 : filterConfig.filterField)
-        ? `<OnChangeField name="${String(filterConfig.filterField.name)}">
-                            {(value, previousValue) => {
-                                if (value.id !== previousValue.id) {
-                                    form.change("${String(config.name)}", undefined);
-                                }
-                            }}
-                        </OnChangeField>`
-        : ``}`;
-    return {
-        code,
-        hooksCode: "",
-        formFragmentFields,
-        gqlDocuments: {},
-        imports,
-        formProps,
-        formValuesConfig: [formValueConfig],
-        finalFormConfig,
-    };
-}

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

@@ -1,16 +0,0 @@
-import { type IntrospectionField, type IntrospectionQuery } from "graphql";
-interface ErrorEnumsResult {
-    createErrorEnum?: string;
-    updateErrorEnum?: string;
-    useDifferentEnums: boolean;
-}
-/**
- * Extracts error enum type names from create and update mutations.
- * Navigates: Mutation → return type → payload object → errors field → LIST → error object → code field → ENUM
- */
-export declare function extractErrorEnumsFromMutations({ createMutationType, updateMutationType, gqlIntrospection, }: {
-    createMutationType: IntrospectionField | null;
-    updateMutationType: IntrospectionField | null;
-    gqlIntrospection: IntrospectionQuery;
-}): ErrorEnumsResult;
-export {};

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

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractErrorEnumsFromMutations = extractErrorEnumsFromMutations;
-/**
- * Extracts error enum type names from create and update mutations.
- * Navigates: Mutation → return type → payload object → errors field → LIST → error object → code field → ENUM
- */
-function extractErrorEnumsFromMutations({ createMutationType, updateMutationType, gqlIntrospection, }) {
-    const createErrorEnum = createMutationType ? extractErrorEnumFromMutation(createMutationType, gqlIntrospection) : undefined;
-    const updateErrorEnum = updateMutationType ? extractErrorEnumFromMutation(updateMutationType, gqlIntrospection) : undefined;
-    const useDifferentEnums = Boolean(createErrorEnum && updateErrorEnum && createErrorEnum !== updateErrorEnum);
-    return {
-        createErrorEnum,
-        updateErrorEnum,
-        useDifferentEnums,
-    };
-}
-/**
- * Extracts error enum type name from a single mutation field.
- * Returns undefined if mutation doesn't have error enum.
- */
-function extractErrorEnumFromMutation(mutationType, gqlIntrospection) {
-    try {
-        // 1. Get return type, unwrap NON_NULL if present
-        let returnType = mutationType.type;
-        if (returnType.kind === "NON_NULL") {
-            returnType = returnType.ofType;
-        }
-        // 2. Check if return type is an OBJECT (payload type)
-        if (returnType.kind !== "OBJECT") {
-            return undefined;
-        }
-        // 3. Find the payload object type in introspection schema
-        const payloadType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === returnType.name);
-        if (!payloadType) {
-            return undefined;
-        }
-        // 4. Find "errors" field in the payload object
-        const errorsField = payloadType.fields.find((field) => field.name === "errors");
-        if (!errorsField) {
-            return undefined;
-        }
-        // 5. Extract enum from errors field
-        return extractEnumFromErrorsField(errorsField, gqlIntrospection);
-    }
-    catch (_a) {
-        // If anything goes wrong during traversal, return undefined
-        return undefined;
-    }
-}
-/**
- * Extracts enum type name from the errors field.
- * Traverses: errors field → unwrap NON_NULL → unwrap LIST → unwrap NON_NULL → error OBJECT → code field → ENUM
- */
-function extractEnumFromErrorsField(errorsField, gqlIntrospection) {
-    try {
-        // 1. Get errors field type, unwrap NON_NULL if present
-        let errorsType = errorsField.type;
-        if (errorsType.kind === "NON_NULL") {
-            errorsType = errorsType.ofType;
-        }
-        // 2. Check if it's a LIST
-        if (errorsType.kind !== "LIST") {
-            return undefined;
-        }
-        // 3. Get the list item type, unwrap NON_NULL if present
-        let errorItemType = errorsType.ofType;
-        if (errorItemType.kind === "NON_NULL") {
-            errorItemType = errorItemType.ofType;
-        }
-        // 4. Check if item type is an OBJECT (error type)
-        if (errorItemType.kind !== "OBJECT") {
-            return undefined;
-        }
-        // 5. Find the error object type in introspection schema
-        const errorObjectType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === errorItemType.name);
-        if (!errorObjectType) {
-            return undefined;
-        }
-        // 6. Find "code" field in the error object
-        const codeField = errorObjectType.fields.find((field) => field.name === "code");
-        if (!codeField) {
-            return undefined;
-        }
-        // 7. Get code field type, unwrap NON_NULL if present
-        let codeType = codeField.type;
-        if (codeType.kind === "NON_NULL") {
-            codeType = codeType.ofType;
-        }
-        // 8. Check if it's an ENUM
-        if (codeType.kind !== "ENUM") {
-            return undefined;
-        }
-        // 9. Return the enum type name
-        return codeType.name;
-    }
-    catch (_a) {
-        return undefined;
-    }
-}

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

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

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

@@ -1,22 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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,24 +0,0 @@
-import { type FormConfig, type FormFieldConfig } from "../../generate-command";
-import { type Imports } from "../../utils/generateImportsCode";
-type AdornmentData = {
-    adornmentString: string;
-    adornmentImport?: {
-        name: string;
-        importPath: string;
-    };
-};
-/**
- * Helper function that builds various options needed for generating form fields.
- */
-export declare function buildFormFieldOptions({ config, formConfig, }: {
-    config: FormFieldConfig<any>;
-    formConfig: FormConfig<any>;
-}): {
-    name: string;
-    formattedMessageRootId: any;
-    fieldLabel: string;
-    startAdornment: AdornmentData;
-    endAdornment: AdornmentData;
-    imports: Imports;
-};
-export {};

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

@@ -1,85 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFormFieldOptions = buildFormFieldOptions;
-const camelCaseToHumanReadable_1 = require("../../utils/camelCaseToHumanReadable");
-const convertConfigImport_1 = require("../../utils/convertConfigImport");
-const intl_1 = require("../../utils/intl");
-const runtimeTypeGuards_1 = require("../../utils/runtimeTypeGuards");
-const buildAdornmentData = ({ adornmentData }) => {
-    let adornmentString = "";
-    let adornmentImport = { name: "", importPath: "" };
-    if (typeof adornmentData === "string") {
-        return { adornmentString: adornmentData };
-    }
-    if (typeof adornmentData.icon === "string") {
-        adornmentString = `<${adornmentData.icon}Icon />`;
-        adornmentImport = {
-            name: `${adornmentData.icon} as ${adornmentData.icon}Icon`,
-            importPath: "@comet/admin-icons",
-        };
-    }
-    else if (typeof adornmentData.icon === "object") {
-        if ((0, runtimeTypeGuards_1.isGeneratorConfigImport)(adornmentData.icon)) {
-            adornmentString = `<${adornmentData.icon.name} />`;
-            adornmentImport = (0, convertConfigImport_1.convertConfigImport)(adornmentData.icon);
-        }
-        else {
-            const _a = adornmentData.icon, { name } = _a, iconProps = __rest(_a, ["name"]);
-            adornmentString = `<${name}Icon
-                ${Object.entries(iconProps)
-                .map(([key, value]) => `${key}="${value}"`)
-                .join("\n")}
-            />`;
-            adornmentImport = {
-                name: `${adornmentData.icon.name} as ${adornmentData.icon.name}Icon`,
-                importPath: "@comet/admin-icons",
-            };
-        }
-    }
-    return { adornmentString, adornmentImport };
-};
-/**
- * Helper function that builds various options needed for generating form fields.
- */
-function buildFormFieldOptions({ config, formConfig, }) {
-    const rootGqlType = formConfig.gqlType;
-    const name = String(config.name);
-    const formattedMessageRootId = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
-    const fieldLabel = (0, intl_1.generateFormattedMessage)({
-        config: config.label,
-        id: `${formattedMessageRootId}.${name}`,
-        defaultMessage: (0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(name),
-        type: "jsx",
-    });
-    const imports = [];
-    let startAdornment = { adornmentString: "" };
-    let endAdornment = { adornmentString: "" };
-    if ("startAdornment" in config && config.startAdornment) {
-        startAdornment = buildAdornmentData({
-            adornmentData: config.startAdornment,
-        });
-        if (startAdornment.adornmentImport) {
-            imports.push(startAdornment.adornmentImport);
-        }
-    }
-    if ("endAdornment" in config && config.endAdornment) {
-        endAdornment = buildAdornmentData({
-            adornmentData: config.endAdornment,
-        });
-        if (endAdornment.adornmentImport) {
-            imports.push(endAdornment.adornmentImport);
-        }
-    }
-    return { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports };
-}

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

@@ -1,5 +0,0 @@
-import { type ComponentFormFieldConfig } from "../generate-command";
-import { type GenerateFieldsReturn } from "./generateFields";
-export declare function generateComponentFormField({ config }: {
-    config: ComponentFormFieldConfig;
-}): GenerateFieldsReturn;