nextjs-cms 0.5.9 → 0.5.10

package/dist/core/fields/select.js

@@ -1,499 +1,499 @@
-import { Field, baseFieldConfigSchema } from "./field.js";
-import { entityKind } from "../helpers.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 const selectOptionSchema = z.strictObject({
-    value: z.union([z.string(), z.number()]).describe('Stored value for this option'),
-    label: z.string().describe('Human-readable label for the option'),
-});
-export const selectFieldDestinationDbSchema = z.strictObject({
-    table: z.string().min(1).describe('Destination table where select values will be stored'),
-    /**
-     * The identifier of the item that has this select field as a field
-     */
-    itemIdentifier: z.string().min(1).describe('Destination item identifier column'),
-    /**
-     * The identifier of the value of the select option that is coming from the select options
-     */
-    selectIdentifier: z.string().min(1).describe('Destination select identifier column'),
-});
-const selectFieldSharedExtrasSchema = 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(),
-    checkValueExists: z.boolean().optional(),
-});
-const selectFieldDbConfigSchema = selectFieldSharedExtrasSchema.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 selectFieldSectionConfigSchema = selectFieldSharedExtrasSchema.extend({
-    options: z.array(selectOptionSchema).optional(),
-    db: z.never().optional(),
-    section: z.custom().describe('Section to derive select options from'),
-});
-const selectFieldStaticConfigSchema = selectFieldSharedExtrasSchema.extend({
-    options: z.array(selectOptionSchema).min(1).describe('List of static select options'),
-    db: z.never().optional(),
-    section: z.never().optional(),
-});
-export const selectFieldSpecificConfigSchema = z.union([
-    selectFieldDbConfigSchema,
-    selectFieldSectionConfigSchema,
-    selectFieldStaticConfigSchema,
-]);
-export class SelectField extends Field {
-    static [entityKind] = 'SelectField';
-    checkValueExists;
-    optionsType;
-    db;
-    destinationDb = undefined;
-    value = undefined;
-    // private _values: string[] | number[] | undefined
-    section;
-    _itemIdentifier;
-    options;
-    _allOptions;
-    constructor(config) {
-        super(config, 'select');
-        this.checkValueExists = config.checkValueExists ?? false;
-        if (config.section) {
-            this.destinationDb = config.destinationDb;
-            this.section = config.section;
-        }
-        /**
-         * 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
-             */
-            const 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,
-            };
-        }
-        else {
-            throw new Error('Select field requires either db, section or an options array.');
-        }
-    }
-    /**
-     * @param value The value of a single select field,
-     * or values array of multiple select fields if the select is selecting from
-     * a category section with depth higher than 1.
-     */
-    setValue(value) {
-        /**
-         * Set the value
-         */
-        if (value) {
-            /**
-             * Value can be a string of comma separated values if destinationDb is not set
-             */
-            if (typeof value === 'string') {
-                /**
-                 * Split the values by comma and set the value as an array of objects
-                 */
-                const values = value.toString().split(',');
-                values.map((value) => {
-                    if (this.checkValueExists) {
-                        /**
-                         * 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 (!this.value) {
-                            this.value = [];
-                        }
-                        this.value.push({
-                            value: value,
-                            label: '', // TODO: Fix this
-                        });
-                    }
-                });
-            }
-            else {
-                /**
-                 * Value is an array of objects
-                 */
-                this.value = value;
-            }
-        }
-        else {
-            this.value = undefined;
-        }
-    }
-    hasSqlNameAndValue() {
-        return this.destinationDb === undefined;
-    }
-    hasDepth() {
-        return this.section !== undefined && this.section.type === 'category' && (this.section.depth ?? 1) > 1;
-    }
-    /**
-     * Get the value of the field
-     */
-    getValue() {
-        /**
-         * Value is always a string | number
-         */
-        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((item) => item.value).join(',');
-    }
-    exportForClient() {
-        return {
-            ...super.exportForClient(),
-            options: this.options,
-            section: this.section
-                ? {
-                    name: this.section.name,
-                    depth: this.section.type === 'category' ? this.section.depth : 1,
-                }
-                : undefined,
-            /**
-             * Add the values with the level if present
-             */
-            value: this.value?.map((value, index) => ({ ...value, level: index + 1 })),
-        };
-    }
-    async postSubmit(itemId) {
-        if (!this.destinationDb)
-            return;
-        /**
-         * First, check if the select is selecting from a category section with depth higher than 1
-         */
-        // if (!this.hasDepth()) 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) {
-            console.error(error);
-            throw new Error(`${this.label}: Error saving values to the destination table`);
-        }
-    }
-    async postSubmitRollback() {
-        if (!this.destinationDb)
-            return;
-        /**
-         * First, check if the select is selecting from a category section with depth higher than 1
-         */
-        // if (!this.hasDepth()) 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`);
-        }
-    }
-    /**
-     * 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`);
-        }
-    }
-    /**
-     * 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!`);
-        }
-    }
-    /**
-     * 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
-         */
-        const sqlChunks = [];
-        // Initialize the select statement
-        sqlChunks.push(sql `select * from \`${sql.raw(this.db.table)}\``);
-        /**
-         * Check if the select is from a category section with depth higher than 1
-         */
-        if (this.hasDepth()) {
-            /**
-             * Add the where clause to the select statement
-             */
-            sqlChunks.push(sql ` WHERE parent_id IS NULL AND level = 1`);
-        }
-        /**
-         * Add order by clause
-         */
-        sqlChunks.push(sql ` ORDER BY \`${sql.raw(this.db.orderBy ?? this.db.identifier)}\` DESC`);
-        /**
-         * Get the options from the table
-         */
-        const selectOptionsRows = await db.execute(sql.join(sqlChunks));
-        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],
-        }));
-        this._allOptions = this.options;
-        if (this.hasDepth()) {
-            /**
-             * Get all the options
-             */
-            const selectOptionsRows1 = await db.execute(sql `select * from \`${sql.raw(this.db.table)}\` WHERE parent_id IS NOT NULL AND level > 1`);
-            const rows1 = selectOptionsRows1[0];
-            const tempRows = rows1.map((row) => ({
-                value: row[inputSelectTableIdentifierField],
-                label: row[inputSelectTableHeadingField],
-            }));
-            this._allOptions = this._allOptions.concat(tempRows);
-        }
-    }
-    /**
-     * 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 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('Table, identifier and label are required');
-        }
-    }
-    checkRequired() {
-        /**
-         * Check if the field is required
-         */
-        if (this.required) {
-            if (!this.value || this.value.toString().trim().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 checkValueExists is set to true, check if the value exists in the options.
-         * This is important to prevent submitting a value that does not exist in the table. (e.g. tampering with the form)
-         * Default is false.
-         */
-        if (this.checkValueExists && 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._allOptions?.find((option) => option.value.toString() === value.value.toString())) {
-                    throw new Error(`Field ${this.label}: Option ${value.label} does not exist in the options`);
-                }
-            });
-        }
-    }
-}
-const selectFieldDbOptionsSchema = z.strictObject({
-    ...baseFieldConfigSchema.shape,
-    ...selectFieldDbConfigSchema.shape,
-});
-const selectFieldSectionOptionsSchema = z.strictObject({
-    ...baseFieldConfigSchema.shape,
-    ...selectFieldSectionConfigSchema.shape,
-});
-const selectFieldStaticOptionsSchema = z.strictObject({
-    ...baseFieldConfigSchema.shape,
-    ...selectFieldStaticConfigSchema.shape,
-});
-export const selectFieldOptionsSchema = z.union([
-    selectFieldDbOptionsSchema,
-    selectFieldSectionOptionsSchema,
-    selectFieldStaticOptionsSchema,
-]);
-const selectFieldConfigSchema = z.intersection(selectFieldOptionsSchema, z.strictObject({
-    type: z.literal('select').describe('The type of the field'),
-    optionsType: z.enum(['static', 'db', 'section']).describe('Source of select options'),
-    build: z.function().output(z.instanceof(SelectField)).describe('Build a SelectField instance from this config'),
-}));
-/**
- * Helper function to create a select field configuration
- * Returns a config object with a build() method that can be serialized and used anywhere.
- */
-export function selectField(field) {
-    const result = selectFieldOptionsSchema.safeParse(field);
-    if (!result.success) {
-        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
-    }
-    const parsedField = result.data;
-    let optionsType;
-    if (parsedField.options && parsedField.options.length > 0) {
-        optionsType = 'static';
-    }
-    else if (parsedField.db) {
-        optionsType = 'db';
-    }
-    else if (parsedField.section) {
-        optionsType = 'section';
-    }
-    else {
-        throw new Error(`[Field: ${parsedField.name}]: You have to assign options for the select field, you can assign one of the following sources: [db, section, options]`);
-    }
-    const config = {
-        ...parsedField,
-        type: 'select',
-        optionsType,
-        build() {
-            // Use the original field config directly (it doesn't have build() method)
-            return new SelectField(parsedField);
-        },
-    };
-    return config;
-}
+import { Field, baseFieldConfigSchema } from './field.js';
+import { entityKind } from '../helpers/index.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 const selectOptionSchema = z.strictObject({
+    value: z.union([z.string(), z.number()]).describe('Stored value for this option'),
+    label: z.string().describe('Human-readable label for the option'),
+});
+export const selectFieldDestinationDbSchema = z.strictObject({
+    table: z.string().min(1).describe('Destination table where select values will be stored'),
+    /**
+     * The identifier of the item that has this select field as a field
+     */
+    itemIdentifier: z.string().min(1).describe('Destination item identifier column'),
+    /**
+     * The identifier of the value of the select option that is coming from the select options
+     */
+    selectIdentifier: z.string().min(1).describe('Destination select identifier column'),
+});
+const selectFieldSharedExtrasSchema = 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(),
+    checkValueExists: z.boolean().optional(),
+});
+const selectFieldDbConfigSchema = selectFieldSharedExtrasSchema.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 selectFieldSectionConfigSchema = selectFieldSharedExtrasSchema.extend({
+    options: z.array(selectOptionSchema).optional(),
+    db: z.never().optional(),
+    section: z.custom().describe('Section to derive select options from'),
+});
+const selectFieldStaticConfigSchema = selectFieldSharedExtrasSchema.extend({
+    options: z.array(selectOptionSchema).min(1).describe('List of static select options'),
+    db: z.never().optional(),
+    section: z.never().optional(),
+});
+export const selectFieldSpecificConfigSchema = z.union([
+    selectFieldDbConfigSchema,
+    selectFieldSectionConfigSchema,
+    selectFieldStaticConfigSchema,
+]);
+export class SelectField extends Field {
+    static [entityKind] = 'SelectField';
+    checkValueExists;
+    optionsType;
+    db;
+    destinationDb = undefined;
+    value = undefined;
+    // private _values: string[] | number[] | undefined
+    section;
+    _itemIdentifier;
+    options;
+    _allOptions;
+    constructor(config) {
+        super(config, 'select');
+        this.checkValueExists = config.checkValueExists ?? false;
+        if (config.section) {
+            this.destinationDb = config.destinationDb;
+            this.section = config.section;
+        }
+        /**
+         * 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
+             */
+            const 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,
+            };
+        }
+        else {
+            throw new Error('Select field requires either db, section or an options array.');
+        }
+    }
+    /**
+     * @param value The value of a single select field,
+     * or values array of multiple select fields if the select is selecting from
+     * a category section with depth higher than 1.
+     */
+    setValue(value) {
+        /**
+         * Set the value
+         */
+        if (value) {
+            /**
+             * Value can be a string of comma separated values if destinationDb is not set
+             */
+            if (typeof value === 'string') {
+                /**
+                 * Split the values by comma and set the value as an array of objects
+                 */
+                const values = value.toString().split(',');
+                values.map((value) => {
+                    if (this.checkValueExists) {
+                        /**
+                         * 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 (!this.value) {
+                            this.value = [];
+                        }
+                        this.value.push({
+                            value: value,
+                            label: '', // TODO: Fix this
+                        });
+                    }
+                });
+            }
+            else {
+                /**
+                 * Value is an array of objects
+                 */
+                this.value = value;
+            }
+        }
+        else {
+            this.value = undefined;
+        }
+    }
+    hasSqlNameAndValue() {
+        return this.destinationDb === undefined;
+    }
+    hasDepth() {
+        return this.section !== undefined && this.section.type === 'category' && (this.section.depth ?? 1) > 1;
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        /**
+         * Value is always a string | number
+         */
+        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((item) => item.value).join(',');
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            options: this.options,
+            section: this.section
+                ? {
+                    name: this.section.name,
+                    depth: this.section.type === 'category' ? this.section.depth : 1,
+                }
+                : undefined,
+            /**
+             * Add the values with the level if present
+             */
+            value: this.value?.map((value, index) => ({ ...value, level: index + 1 })),
+        };
+    }
+    async postSubmit(itemId) {
+        if (!this.destinationDb)
+            return;
+        /**
+         * First, check if the select is selecting from a category section with depth higher than 1
+         */
+        // if (!this.hasDepth()) 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) {
+            console.error(error);
+            throw new Error(`${this.label}: Error saving values to the destination table`);
+        }
+    }
+    async postSubmitRollback() {
+        if (!this.destinationDb)
+            return;
+        /**
+         * First, check if the select is selecting from a category section with depth higher than 1
+         */
+        // if (!this.hasDepth()) 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`);
+        }
+    }
+    /**
+     * 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`);
+        }
+    }
+    /**
+     * 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!`);
+        }
+    }
+    /**
+     * 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
+         */
+        const sqlChunks = [];
+        // Initialize the select statement
+        sqlChunks.push(sql `select * from \`${sql.raw(this.db.table)}\``);
+        /**
+         * Check if the select is from a category section with depth higher than 1
+         */
+        if (this.hasDepth()) {
+            /**
+             * Add the where clause to the select statement
+             */
+            sqlChunks.push(sql ` WHERE parent_id IS NULL AND level = 1`);
+        }
+        /**
+         * Add order by clause
+         */
+        sqlChunks.push(sql ` ORDER BY \`${sql.raw(this.db.orderBy ?? this.db.identifier)}\` DESC`);
+        /**
+         * Get the options from the table
+         */
+        const selectOptionsRows = await db.execute(sql.join(sqlChunks));
+        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],
+        }));
+        this._allOptions = this.options;
+        if (this.hasDepth()) {
+            /**
+             * Get all the options
+             */
+            const selectOptionsRows1 = await db.execute(sql `select * from \`${sql.raw(this.db.table)}\` WHERE parent_id IS NOT NULL AND level > 1`);
+            const rows1 = selectOptionsRows1[0];
+            const tempRows = rows1.map((row) => ({
+                value: row[inputSelectTableIdentifierField],
+                label: row[inputSelectTableHeadingField],
+            }));
+            this._allOptions = this._allOptions.concat(tempRows);
+        }
+    }
+    /**
+     * 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 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('Table, identifier and label are required');
+        }
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         */
+        if (this.required) {
+            if (!this.value || this.value.toString().trim().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 checkValueExists is set to true, check if the value exists in the options.
+         * This is important to prevent submitting a value that does not exist in the table. (e.g. tampering with the form)
+         * Default is false.
+         */
+        if (this.checkValueExists && 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._allOptions?.find((option) => option.value.toString() === value.value.toString())) {
+                    throw new Error(`Field ${this.label}: Option ${value.label} does not exist in the options`);
+                }
+            });
+        }
+    }
+}
+const selectFieldDbOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectFieldDbConfigSchema.shape,
+});
+const selectFieldSectionOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectFieldSectionConfigSchema.shape,
+});
+const selectFieldStaticOptionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...selectFieldStaticConfigSchema.shape,
+});
+export const selectFieldOptionsSchema = z.union([
+    selectFieldDbOptionsSchema,
+    selectFieldSectionOptionsSchema,
+    selectFieldStaticOptionsSchema,
+]);
+const selectFieldConfigSchema = z.intersection(selectFieldOptionsSchema, z.strictObject({
+    type: z.literal('select').describe('The type of the field'),
+    optionsType: z.enum(['static', 'db', 'section']).describe('Source of select options'),
+    build: z.function().output(z.instanceof(SelectField)).describe('Build a SelectField instance from this config'),
+}));
+/**
+ * Helper function to create a select field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere.
+ */
+export function selectField(field) {
+    const result = selectFieldOptionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const parsedField = result.data;
+    let optionsType;
+    if (parsedField.options && parsedField.options.length > 0) {
+        optionsType = 'static';
+    }
+    else if (parsedField.db) {
+        optionsType = 'db';
+    }
+    else if (parsedField.section) {
+        optionsType = 'section';
+    }
+    else {
+        throw new Error(`[Field: ${parsedField.name}]: You have to assign options for the select field, you can assign one of the following sources: [db, section, options]`);
+    }
+    const config = {
+        ...parsedField,
+        type: 'select',
+        optionsType,
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new SelectField(parsedField);
+        },
+    };
+    return config;
+}