nextjs-cms 0.0.1 → 0.5.1

package/dist/core/fields/selectMultiple.d.ts

@@ -0,0 +1,236 @@
+import type { BaseFieldConfig } from './field';
+import { Field } from './field';
+import { entityKind } from '../helpers';
+import type { SelectOption } from './select';
+import type { HasItemsSection, CategorySection } from '../sections';
+import * as z from 'zod';
+declare const selectMultipleFieldConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodNever>;
+    db: z.ZodObject<{
+        table: z.ZodString;
+        identifier: z.ZodString;
+        label: z.ZodString;
+        orderBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    section: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>, z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    db: z.ZodOptional<z.ZodNever>;
+    section: z.ZodCustom<{
+        type: "has_items" | "category";
+        name: string;
+        depth?: number;
+        build(): HasItemsSection | CategorySection;
+    }, {
+        type: "has_items" | "category";
+        name: string;
+        depth?: number;
+        build(): HasItemsSection | CategorySection;
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    db: z.ZodOptional<z.ZodNever>;
+    section: z.ZodOptional<z.ZodNever>;
+}, z.core.$strict>]>;
+type SelectMultipleFieldConfig = z.infer<typeof selectMultipleFieldConfigSchema>;
+export declare class SelectMultipleField extends Field<'select_multiple', SelectMultipleFieldConfig> {
+    static readonly [entityKind]: string;
+    readonly checkValuesExist: boolean;
+    readonly optionsType: 'db' | 'section' | 'static';
+    readonly db: {
+        table: string;
+        identifier: string;
+        label: string;
+        orderBy?: string;
+    };
+    options: SelectOption[] | undefined;
+    readonly destinationDb?: {
+        table: string;
+        itemIdentifier: string;
+        selectIdentifier: string;
+    };
+    value: SelectOption[] | undefined;
+    private _itemIdentifier;
+    constructor(config: BaseFieldConfig<SelectMultipleFieldConfig>);
+    static getEntityKind(): string;
+    hasSqlNameAndValue(): boolean;
+    /**
+     * Get the value of the field
+     */
+    getValue(): {
+        value: string | number;
+        label: string;
+    }[] | undefined;
+    /**
+     * Get the value of the field when submitting to the database
+     */
+    getSubmitValue(): string | SelectOption[] | undefined;
+    /**
+     * Set the value of the field
+     * @param value can be a string of comma-separated values coming from the db table,
+     * or an array of `SelectOption` objects coming from the client
+     */
+    setValue(value: string | SelectOption[]): void;
+    exportForClient(): {
+        options: {
+            value: string | number;
+            label: string;
+        }[] | undefined;
+        value: {
+            value: string | number;
+            label: string;
+        }[] | undefined;
+        type: "select_multiple";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+    };
+    postSubmit(itemId: string): Promise<void>;
+    postSubmitRollback(): Promise<void>;
+    /**
+     * Build the field to be used in a form
+     */
+    build(): Promise<void>;
+    private fetchOptions;
+    /**
+     * Check if table and columns exist
+     * @private
+     */
+    private checkDBTableAndColumns;
+    /**
+     * Check if destination table and columns exist
+     * @private
+     */
+    private checkDestinationDBTableAndColumns;
+    /**
+     * Check the db config is set
+     * @private
+     */
+    private checkDBConfig;
+    /**
+     * Check the destination db config is set
+     * @private
+     */
+    private checkDestinationDBConfig;
+    checkRequired(): void;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type SelectMultipleFieldClientConfig = ReturnType<SelectMultipleField['exportForClient']>;
+declare const selectMultipleFieldHelperConfigSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodNever>;
+    db: z.ZodObject<{
+        table: z.ZodString;
+        identifier: z.ZodString;
+        label: z.ZodString;
+        orderBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    section: z.ZodOptional<z.ZodNever>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>, z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    db: z.ZodOptional<z.ZodNever>;
+    section: z.ZodCustom<{
+        type: "has_items" | "category";
+        name: string;
+        depth?: number;
+        build(): HasItemsSection | CategorySection;
+    }, {
+        type: "has_items" | "category";
+        name: string;
+        depth?: number;
+        build(): HasItemsSection | CategorySection;
+    }>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>, z.ZodObject<{
+    destinationDb: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        itemIdentifier: z.ZodString;
+        selectIdentifier: z.ZodString;
+    }, z.core.$strict>>;
+    checkValuesExist: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    db: z.ZodOptional<z.ZodNever>;
+    section: z.ZodOptional<z.ZodNever>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>]>, z.ZodObject<{
+    type: z.ZodLiteral<"select_multiple">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<SelectMultipleField, SelectMultipleField>>;
+}, z.core.$strict>>;
+/**
+ * SelectMultiple field configuration type
+ * This is a plain object that can be serialized and used anywhere.
+ */
+export type SelectMultipleFieldConfigType = z.infer<typeof selectMultipleFieldHelperConfigSchema>;
+/**
+ * Helper function to create a multiple select field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere.
+ */
+export declare function selectMultipleField(field: BaseFieldConfig<SelectMultipleFieldConfig>): SelectMultipleFieldConfigType;
+export {};
+//# sourceMappingURL=selectMultiple.d.ts.map

package/dist/core/fields/selectMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectMultiple.d.ts","sourceRoot":"","sources":["../../../src/core/fields/selectMultiple.ts"],"names":[],"mappings":"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"}

package/dist/core/fields/selectMultiple.js

@@ -0,0 +1,417 @@
+import { Field, baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import { selectFieldDestinationDbSchema, selectOptionSchema } from './select';
+import { MysqlTableChecker } from '../db';
+import { db } from '../../db/client';
+import { sql } from 'drizzle-orm';
+import chalk from 'chalk';
+import * as z from 'zod';
+/*export type SelectMultipleValue = {
+    value: string | number
+    label: string
+}*/
+const selectMultipleSharedExtrasSchema = z.strictObject({
+    /**
+     * A destination table where the select values will be saved
+     * When this is set, the value of the field will only be saved in the destination table as one row per each value
+     */
+    destinationDb: selectFieldDestinationDbSchema.optional(),
+    checkValuesExist: z.boolean().optional().describe('Validate submitted values exist in the options'),
+});
+const selectMultipleFieldDbConfigSchema = selectMultipleSharedExtrasSchema.extend({
+    options: z.never().optional(),
+    db: z
+        .strictObject({
+        table: z.string().min(1).describe('Database table to read select options from'),
+        identifier: z.string().min(1).describe('Identifier column for the option'),
+        label: z.string().min(1).describe('Label column for the option'),
+        orderBy: z.string().optional().describe('Optional order by column'),
+    })
+        .describe('Database configuration for select options'),
+    section: z.never().optional(),
+});
+const selectMultipleFieldSectionConfigSchema = selectMultipleSharedExtrasSchema.extend({
+    options: z.array(selectOptionSchema).optional(),
+    db: z.never().optional(),
+    section: z
+        .custom()
+        .describe('Section to derive select options from'),
+});
+const selectMultipleFieldStaticConfigSchema = selectMultipleSharedExtrasSchema.extend({
+    options: z.array(selectOptionSchema).min(1).describe('List of static select options'),
+    db: z.never().optional(),
+    section: z.never().optional(),
+});
+const selectMultipleFieldConfigSchema = z.union([
+    selectMultipleFieldDbConfigSchema,
+    selectMultipleFieldSectionConfigSchema,
+    selectMultipleFieldStaticConfigSchema,
+]);
+export class SelectMultipleField extends Field {
+    static [entityKind] = 'SelectMultipleField';
+    checkValuesExist;
+    optionsType;
+    db;
+    /*protected*/ options;
+    destinationDb;
+    value = undefined;
+    _itemIdentifier;
+    constructor(config) {
+        super(config, 'select_multiple');
+        this.checkValuesExist = config.checkValuesExist ?? true;
+        this.destinationDb = config.destinationDb;
+        /**
+         * If options are static, set them
+         */
+        if (config.options && config.options?.length > 0) {
+            this.options = config.options;
+            this.optionsType = 'static';
+            this.db = null;
+        }
+        else if (config.db) {
+            /**
+             * Else, check if the db config is set
+             */
+            this.db = config.db;
+            this.optionsType = 'db';
+        }
+        else if (config.section) {
+            /**
+             * Else, check if the section config is set
+             */
+            /**
+             * Runtime validation: Ensure the section is a HasItemsSection or CategorySection
+             * TypeScript ensures type safety at compile time, but runtime data (from JSON/APIs)
+             * can violate types, so we validate here for safety.
+             */
+            const sectionType = config.section.type;
+            if (sectionType !== 'has_items' && sectionType !== 'category') {
+                const message = `[SelectMultipleField: ${this.label}]: Section must be a HasItemsSection or CategorySection, but got type: ${sectionType ?? 'undefined'}`;
+                console.error(chalk.red.bold(message));
+                console.error(chalk.yellow('Please make sure the section is a HasItemsSection or CategorySection'));
+                throw new Error(message);
+            }
+            /**
+             * Build the section and set the options type to section
+             */
+            let section = config.section.build();
+            this.optionsType = 'section';
+            this.db = {
+                table: section.db.table,
+                identifier: section.db.identifier.name,
+                label: section.headingField.name,
+                orderBy: section.db.orderByField ? section.db.orderByField.name : section.db.identifier.name,
+            };
+            /**
+             * Set the section instance to undefined to avoid memory leaks
+             */
+            section = undefined;
+        }
+        else {
+            throw new Error('Select field requires either db, section or an options array.');
+        }
+    }
+    static getEntityKind() {
+        return SelectMultipleField[entityKind];
+    }
+    hasSqlNameAndValue() {
+        return this.destinationDb === undefined;
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Get the value of the field when submitting to the database
+     */
+    getSubmitValue() {
+        if (!this.hasSqlNameAndValue())
+            return;
+        /**
+         * Set the value as a comma separated string of the values
+         */
+        return this.value?.map((value) => value.value).join(',');
+    }
+    /**
+     * Set the value of the field
+     * @param value can be a string of comma-separated values coming from the db table,
+     * or an array of `SelectOption` objects coming from the client
+     */
+    setValue(value) {
+        if (typeof value === 'string') {
+            /**
+             * Value can be an encoded JSON string sent from the client,
+             * try parsing the value as a JSON string
+             */
+            let decoded;
+            try {
+                decoded = JSON.parse(value);
+            }
+            catch (error) {
+                decoded = undefined;
+            }
+            if (!Array.isArray(decoded)) {
+                /**
+                 * If the decoded value is not an array (which means it should be a string coming from the db table),
+                 * split the values by comma and set the value as an array of objects
+                 */
+                const values = value.split(',');
+                values.map((value) => {
+                    /**
+                     * Check if the value exists in the options and return the value and text
+                     */
+                    const option = this.options?.find((option) => option.value.toString() === value.toString());
+                    if (option) {
+                        if (!this.value) {
+                            this.value = [];
+                        }
+                        this.value.push(option);
+                    }
+                });
+            }
+            else {
+                /**
+                 * If the decoded value is an array, set the value as the decoded value
+                 */
+                this.value = decoded;
+            }
+        }
+        else {
+            this.value = value;
+        }
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            options: this.options,
+            value: this.value,
+        };
+    }
+    async postSubmit(itemId) {
+        if (!this.destinationDb)
+            return;
+        this._itemIdentifier = itemId;
+        try {
+            /**
+             * Delete the existing values
+             */
+            await db.execute(sql `DELETE FROM \`${sql.raw(this.destinationDb.table)}\` WHERE \`${sql.raw(this.destinationDb.itemIdentifier)}\` = ${this._itemIdentifier}`);
+            /**
+             * Prepare the sql statement
+             */
+            const sqlChunks = [];
+            sqlChunks.push(sql `INSERT INTO \`${sql.raw(this.destinationDb.table)}\` (\`${sql.raw(this.destinationDb.selectIdentifier)}\`, \`${sql.raw(this.destinationDb.itemIdentifier)}\`) VALUES `);
+            /**
+             * Loop through the values and add them to the sql statement values
+             */
+            if (this.value && this.value.length > 0) {
+                const count = this.value.length;
+                this.value.forEach((value, index) => {
+                    sqlChunks.push(sql `(${value.value}, ${this._itemIdentifier})`);
+                    if (index < count - 1) {
+                        /**
+                         * Add a comma to separate the values in the sql statement
+                         */
+                        sqlChunks.push(sql `, `);
+                    }
+                });
+            }
+            /**
+             * Join the sql chunks
+             */
+            const finalSql = sql.join(sqlChunks);
+            /**
+             * Execute the sql statement
+             */
+            await db.execute(finalSql);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error saving values to the destination table`);
+        }
+    }
+    async postSubmitRollback() {
+        if (!this.destinationDb)
+            return;
+        if (!this._itemIdentifier) {
+            throw new Error(`${this.label}: Item identifier is not set. Make sure to set the item identifier by calling postSubmit() before calling postSubmitRollback()`);
+        }
+        try {
+            await db.execute(sql `DELETE FROM \`${sql.raw(this.destinationDb.table)}\` WHERE \`${sql.raw(this.destinationDb.itemIdentifier)}\` = ${this._itemIdentifier}`);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error deleting values from the destination table`);
+        }
+    }
+    /**
+     * Build the field to be used in a form
+     */
+    async build() {
+        if (this.destinationDb) {
+            this.checkDestinationDBConfig();
+            await this.checkDestinationDBTableAndColumns();
+        }
+        /**
+         * If options are already set, return
+         */
+        if (this.options && this.optionsType === 'static')
+            return;
+        /**
+         * Initialize the select db and options
+         */
+        this.checkDBConfig();
+        await this.checkDBTableAndColumns();
+        /**
+         * Fetch the options
+         */
+        await this.fetchOptions();
+    }
+    async fetchOptions() {
+        /**
+         * Let's get the options for the select input
+         */
+        let selectStatement = `select * from \`${this.db.table}\` ORDER BY \`${this.db.orderBy ?? this.db.identifier}\` DESC`;
+        /**
+         * Get the options from the table
+         */
+        const selectOptionsRows = await db.execute(sql.raw(selectStatement));
+        const rows = selectOptionsRows[0];
+        const inputSelectTableIdentifierField = this.db.identifier;
+        const inputSelectTableHeadingField = this.db.label;
+        /**
+         * Set the options
+         */
+        this.options = rows.map((row) => ({
+            value: row[inputSelectTableIdentifierField],
+            label: row[inputSelectTableHeadingField],
+        }));
+    }
+    /**
+     * Check if table and columns exist
+     * @private
+     */
+    async checkDBTableAndColumns() {
+        const columns = await MysqlTableChecker.getColumns(this.db.table);
+        if (!columns.includes(this.db.identifier) || !columns.includes(this.db.label)) {
+            throw new Error(`Field ${this.label}: Table ${this.db.table} and/or columns: ${this.db.identifier}, ${this.db.label} do not exist in the database!`);
+        }
+    }
+    /**
+     * Check if destination table and columns exist
+     * @private
+     */
+    async checkDestinationDBTableAndColumns() {
+        if (!this.destinationDb) {
+            throw new Error(`Field ${this.label}: Destination table, select identifier and item identifier are required`);
+        }
+        const columns = await MysqlTableChecker.getColumns(this.destinationDb.table);
+        if (!columns.includes(this.destinationDb.selectIdentifier) ||
+            !columns.includes(this.destinationDb.itemIdentifier)) {
+            throw new Error(`Field ${this.label}: Table ${this.destinationDb.table} and/or columns: ${this.destinationDb.selectIdentifier}, ${this.destinationDb.itemIdentifier} do not exist in the database!`);
+        }
+    }
+    /**
+     * Check the db config is set
+     * @private
+     */
+    checkDBConfig() {
+        if (this.db.table.trim().length === 0 ||
+            this.db.identifier.trim().length === 0 ||
+            this.db.label.trim().length === 0) {
+            throw new Error(`Field ${this.label}: Select table, identifier and label are required`);
+        }
+    }
+    /**
+     * Check the destination db config is set
+     * @private
+     */
+    checkDestinationDBConfig() {
+        if (this.destinationDb?.table.trim().length === 0 ||
+            this.destinationDb?.selectIdentifier.trim().length === 0 ||
+            this.destinationDb?.itemIdentifier.trim().length === 0) {
+            throw new Error(`Field ${this.label}: Destination table, select identifier and item identifier are required`);
+        }
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         */
+        if (this.required) {
+            if (!this.value || this.value.length === 0) {
+                throw new Error(`Field ${this.label} is required`);
+            }
+        }
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        if (this.optionsType !== 'static') {
+            this.checkDBConfig();
+            await this.checkDBTableAndColumns();
+            /**
+             * Fetch the options
+             */
+            await this.fetchOptions();
+        }
+        if (this.destinationDb) {
+            this.checkDestinationDBConfig();
+            await this.checkDestinationDBTableAndColumns();
+        }
+        if (this.checkValuesExist && this.value && this.value.length > 0) {
+            /**
+             * Check if the values exist in the table
+             * This is now safe because we have verified the table and columns exist in the database
+             */
+            this.value.forEach((value) => {
+                if (!this.options?.find((option) => option.value.toString() === value.value.toString())) {
+                    throw new Error(`Field ${this.label}: Option ${value.label} does not exist in the options`);
+                }
+            });
+        }
+    }
+}
+const selectMultipleFieldDbOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectMultipleFieldDbConfigSchema.shape,
+});
+const selectMultipleFieldSectionOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectMultipleFieldSectionConfigSchema.shape,
+});
+const selectMultipleFieldStaticOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectMultipleFieldStaticConfigSchema.shape,
+});
+const selectMultipleFieldOptionsSchema = z.union([
+    selectMultipleFieldDbOptionsSchema,
+    selectMultipleFieldSectionOptionsSchema,
+    selectMultipleFieldStaticOptionsSchema,
+]);
+const selectMultipleFieldHelperConfigSchema = z.intersection(selectMultipleFieldOptionsSchema, z.strictObject({
+    type: z.literal('select_multiple').describe('The type of the field'),
+    build: z
+        .function()
+        .output(z.instanceof(SelectMultipleField))
+        .describe('Build a SelectMultipleField instance from this config'),
+}));
+/**
+ * Helper function to create a multiple select field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere.
+ */
+export function selectMultipleField(field) {
+    const result = selectMultipleFieldOptionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const parsedField = result.data;
+    const config = {
+        ...parsedField,
+        type: 'select_multiple',
+        build() {
+            return new SelectMultipleField(parsedField);
+        },
+    };
+    return config;
+}