nextjs-cms 0.5.9 → 0.5.10

package/dist/core/fields/selectMultiple.js

@@ -1,417 +1,417 @@
-import { Field, baseFieldConfigSchema } from "./field.js";
-import { entityKind } from "../helpers.js";
-import { selectFieldDestinationDbSchema, selectOptionSchema } from "./select.js";
-import { MysqlTableChecker } from "../db.js";
-import { db } from "../../db/client.js";
-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;
-}
+import { Field, baseFieldConfigSchema } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import { selectFieldDestinationDbSchema, selectOptionSchema } from './select.js';
+import { MysqlTableChecker } from '../db/index.js';
+import { db } from '../../db/client.js';
+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;
+}