nextjs-cms 0.0.1 → 0.5.1

package/dist/core/fields/document.js

@@ -0,0 +1,277 @@
+import { baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import fs from 'fs';
+import { customAlphabet } from 'nanoid';
+import path from 'path';
+import { FileField } from './fileField';
+import { getCMSConfig } from '../config';
+const maxFileSizeSchema = z.strictObject({
+    size: z.number().describe('Maximum file size'),
+    unit: z.enum(['kb', 'mb']).describe('Size unit'),
+});
+const configSchema = z.strictObject({
+    /**
+     * Maximum file size
+     * @example
+     * maxFileSize: {
+     *    size: 512,
+     *    unit: 'kb',
+     *    }
+     */
+    maxFileSize: maxFileSizeSchema.optional(),
+    /**
+     * Allowed document types
+     * @example
+     * type: ['pdf', 'doc', 'docx']
+     * @default ['pdf']
+     */
+    type: z.array(z.enum(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'csv'])).optional(),
+});
+export class DocumentField extends FileField {
+    static [entityKind] = 'DocumentField';
+    maxFileSize;
+    mimeType;
+    extensions;
+    possibleExtensions = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'csv'];
+    /**
+     * _file is the file object if it's present
+     * Whereas the value is the path to the file
+     */
+    _file;
+    _buffer;
+    _folder;
+    _allowedExtensions;
+    uploadsFolder = getCMSConfig().files.upload.uploadPath;
+    constructor(config, file) {
+        super(config, 'document');
+        if (file) {
+            this._file = file;
+        }
+        this.maxFileSize = config.maxFileSize ?? { size: 2, unit: 'mb' };
+        /**
+         * Check if the config type is valid
+         */
+        if (config.type && config.type.some((type) => !this.possibleExtensions.includes(type))) {
+            throw new Error(`Invalid document type provided: ${config.type.join(', ')}, allowed types are: ${this.possibleExtensions.join(', ')}`);
+        }
+        this.extensions = config.type ?? ['pdf'];
+        /**
+         * Extract the mime types from the extensions
+         * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+         */
+        this.mimeType = this.extensions.map((e) => {
+            switch (e) {
+                case 'pdf':
+                    return 'application/pdf';
+                case 'doc':
+                    return 'application/msword';
+                case 'docx':
+                    return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+                case 'xls':
+                    return 'application/vnd.ms-excel';
+                case 'xlsx':
+                    return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+                case 'ppt':
+                    return 'application/vnd.ms-powerpoint';
+                case 'pptx':
+                    return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+                case 'txt':
+                    return 'text/plain';
+                case 'csv':
+                    return 'text/csv';
+                default:
+                    throw new Error(`Invalid image extension provided: ${e}`);
+            }
+        });
+        /**
+         * Set the allowed extensions, add jpg if jpeg is present
+         */
+        this._allowedExtensions = this.extensions;
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxFileSize: this.maxFileSize,
+            extensions: this._allowedExtensions,
+            mimeType: this.mimeType,
+        };
+    }
+    async readChunkFromFile({ arrayBuffer, length, startPosition = 0, }) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (arrayBuffer) {
+                    const buffer = new Uint8Array(arrayBuffer, startPosition, length);
+                    resolve(buffer);
+                }
+                else {
+                    reject(new Error('Error reading file'));
+                }
+            }
+            catch (error) {
+                reject(new Error('Error reading file'));
+            }
+        });
+    }
+    /**
+     * Write the file to the disk
+     */
+    async writeToFile() {
+        if (!this._folder) {
+            throw new Error(`${this.label}: Folder is not set. Make sure to set the folder by call postSubmit() before writing the file to disk`);
+        }
+        if (!this._buffer) {
+            throw new Error(`${this.label}: Buffer is not set. Make sure to call prepareForSubmission() before writing the file to disk`);
+        }
+        try {
+            /**
+             * If .documents, and 'sectionName' folders don't exist, create them
+             */
+            const documentsFolder = path.join(this.uploadsFolder, '.documents', this._folder);
+            if (!fs.existsSync(documentsFolder)) {
+                fs.mkdirSync(documentsFolder, { recursive: true });
+            }
+            /**
+             * Write the file to disk
+             */
+            await fs.promises.writeFile(path.join(this.uploadsFolder, '.documents', this._folder, this.value), this._buffer);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error writing file to disk ${error.message}`);
+        }
+    }
+    async postSubmit(folder) {
+        if (!this._file)
+            return;
+        this._folder = folder;
+        await this.writeToFile();
+    }
+    async postSubmitRollback() {
+        if (!this._file)
+            return;
+        if (!this._folder) {
+            throw new Error(`${this.label}: Folder is not set. Make sure to set the folder before writing the file to disk`);
+        }
+        try {
+            const pathToFile = path.join(this.uploadsFolder, '.documents', this._folder, this.value);
+            await fs.promises.unlink(pathToFile);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error deleting file from disk`);
+        }
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    setFileName(value) {
+        this.value = value;
+    }
+    setValue(value) {
+        if (typeof value === 'string') {
+            this.setFileName(value);
+            return;
+        }
+        this.setFile(value);
+    }
+    setFile(file) {
+        if (!file || file.size === 0 || file.name?.trim() === '')
+            return;
+        this._file = file;
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         * If it is, check if the file is present
+         * If it's not, throw an error
+         * Note: Those values are coming from the browser (not safe)
+         */
+        if (!this.required)
+            return;
+        if (!this._file || !this._file?.type || !this._file?.name || !this._file?.size) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        if (!this._file)
+            return;
+        /**
+         * Check the actual file size
+         */
+        const arrayBuffer = await this._file.arrayBuffer();
+        this._buffer = Buffer.from(arrayBuffer);
+        if (!this._buffer.length) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+        /**
+         * Check extension
+         */
+        const ext = this._file.name.split('.').pop();
+        if (!ext || !this.extensions.includes(ext)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Read the first 4100 bytes of the file
+         */
+        const chunkBuffer = await this.readChunkFromFile({ arrayBuffer, length: 4100 });
+        /**
+         * Get the file type from the buffer
+         */
+        const { fileTypeFromBuffer } = await import('file-type');
+        const fileType = await fileTypeFromBuffer(chunkBuffer);
+        /**
+         * If the file type is invalid, return an error
+         */
+        if (!fileType) {
+            throw new Error(`${this.label}: Invalid file type`);
+        }
+        /**
+         * Don't just trust the file extension
+         * Check the `fileType.ext` against the allowed extensions
+         */
+        if (!fileType.ext || !this.extensions.includes(fileType.ext)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Generate a random name for the file
+         */
+        this.value = customAlphabet('1234567890abcdef', 21)();
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const documentFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('document').describe('The type of the field'),
+    build: z.function().output(z.instanceof(DocumentField)).describe('Build a DocumentField instance from this config'),
+});
+/**
+ * Helper function to create a document field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function documentField(field) {
+    /**
+     * Validate the field config
+     */
+    const result = optionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const config = {
+        ...field,
+        type: 'document',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new DocumentField(field);
+        },
+    };
+    return config;
+}

package/dist/core/fields/field-group.d.ts

@@ -0,0 +1,18 @@
+import type { Field, FieldConfig } from '.';
+import type { Prettify } from '../types';
+export type FieldGroupOptions = {
+    title?: string;
+    order?: number;
+    fields: FieldConfig[];
+};
+export type FieldGroupConfig = Prettify<FieldGroupOptions> & {
+    type: 'field_group';
+};
+export type FieldGroup = {
+    id: number;
+    title?: string;
+    order?: number;
+    fields: Field[];
+};
+export declare function fieldGroup(group: FieldGroupOptions): FieldGroupConfig;
+//# sourceMappingURL=field-group.d.ts.map

package/dist/core/fields/field-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-group.d.ts","sourceRoot":"","sources":["../../../src/core/fields/field-group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,MAAM,MAAM,iBAAiB,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,GAAG;IACzD,IAAI,EAAE,aAAa,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,KAAK,EAAE,CAAA;CAClB,CAAA;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,CAKrE"}

package/dist/core/fields/field-group.js

@@ -0,0 +1,6 @@
+export function fieldGroup(group) {
+    return {
+        ...group,
+        type: 'field_group',
+    };
+}

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

@@ -0,0 +1,126 @@
+import { entityKind } from '../helpers';
+import type { ConditionalField, ConditionalRule, FieldType } from '../types';
+import * as z from 'zod';
+/**
+ * The Field class is used in the submit class to handle submission of the field
+ * It might also be used in the field factory to create the field in the form?
+ */
+export declare abstract class Field<TType extends FieldType = FieldType, TExtraFieldConfig extends object = object> implements AnyField<TType> {
+    static readonly [entityKind]: string;
+    readonly type: TType;
+    readonly name: string;
+    readonly label: string;
+    readonly required: boolean;
+    /**
+     *  The default value of the field in the DB table,
+     */
+    readonly defaultValue: any;
+    readonly order: number | undefined;
+    readonly groupId: number | undefined;
+    readonly conditionalRules: ConditionalRule[] | undefined;
+    /**
+     * adminGenerated is used to determine if the field is generated by the admin or not.
+     * If set to false, the field will not be included in the form.
+     * If set to 'readonly', the field will be visible in the form as a `readonly` text, but will not be included in the submission.
+     */
+    adminGenerated?: true | false | 'readonly';
+    /**
+     * Destination tables are used to save the value of the field in a different table.
+     * This is useful when we have a select multiple field, or a tags field and we want to save the values in a different table.
+     *
+     * Destination tables store only two identifier fields per row:
+     * - The reference item identifier: The identifier of the item that has this field as a field
+     * - The option identifier: The identifier of the select multiple or tags fields
+     *
+     * Destination tables have no identifier field.
+     * The primary key is automatically set as the combination of the reference item identifier and the option identifier.
+     */
+    readonly destinationDb?: {
+        table: string;
+        itemIdentifier: string;
+        selectIdentifier: string;
+    };
+    /**
+     * Dynamically generated fields based on the value of `conditionalRules` from conditional fields.
+     */
+    conditionalFields: ConditionalField[];
+    value: any;
+    constructor(config: BaseFieldConfig<TExtraFieldConfig>, fieldType: TType);
+    abstract checkRequired(): void;
+    setValue(value: any): void;
+    /**
+     * Perform any action after submitting the form
+     */
+    postSubmit(variable?: any): Promise<void>;
+    postSubmitRollback(): Promise<void>;
+    /**
+     * Get the value of the field
+     */
+    abstract getValue(): any;
+    getSubmitValue(): any;
+    /**
+     * Build the field to be used in a form
+     */
+    build(): Promise<void>;
+    abstract prepareForSubmission(): Promise<void>;
+    /**
+     * Generate a human-readable label from a field name.
+     * This is a static method to avoid recreation on every call.
+     */
+    static generateLabel(name: string): string;
+    exportForClient(): {
+        type: TType;
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    hasSqlNameAndValue(): boolean;
+    /**
+     * Check if field is conditional
+     */
+    isConditional(): boolean;
+}
+export type FieldClientConfig = ReturnType<Field['exportForClient']>;
+export declare const conditionalRuleSchema: z.ZodCustom<ConditionalRule, ConditionalRule>;
+/**
+ * Base field configuration schema
+ * This schema defines the base properties that all fields share
+ * Field types should extend this schema with their specific config
+ */
+export declare const baseFieldConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Set if the field is only visible when all conditions are met.
+     * For now, conditionalRules only support one condition rule.
+     * If the condition is met, the field will be visible.
+     */
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<ConditionalRule, ConditionalRule>>>;
+    /**
+     * adminGenerated is used to determine if the field is generated by the admin or not.
+     * If set to false, the field will not be included in the form.
+     * If set to 'readonly', the field will be visible in the form as a `readonly` text, but will not be included in the submission.
+     */
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * This is the base field configuration
+ * It's used to define the base properties of a field
+ * It can be extended by other field types to add more properties
+ */
+export type BaseFieldConfig<TExtraFieldConfig extends object = object> = z.infer<typeof baseFieldConfigSchema> & TExtraFieldConfig;
+/**
+ * This type represents the base field
+ */
+interface AnyField<TType extends FieldType> extends BaseFieldConfig<{}> {
+    type: TType;
+}
+export {};
+//# sourceMappingURL=field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/core/fields/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC5E,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB;;;GAGG;AACH,8BAAsB,KAAK,CAEvB,KAAK,SAAS,SAAS,GAAG,SAAS,EACnC,iBAAiB,SAAS,MAAM,GAAG,MAAM,CAC3C,YAAW,QAAQ,CAAC,KAAK,CAAC;IAExB,MAAM,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,MAAM,CAAU;IAC9C,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,gBAAgB,EAAE,eAAe,EAAE,GAAG,SAAS,CAAA;IAExD;;;;OAIG;IACH,cAAc,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,UAAU,CAAA;IAE1C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE;QACrB,KAAK,EAAE,MAAM,CAAA;QACb,cAAc,EAAE,MAAM,CAAA;QACtB,gBAAgB,EAAE,MAAM,CAAA;KAC3B,CAAA;IAED;;OAEG;IACI,iBAAiB,EAAE,gBAAgB,EAAE,CAAK;IACnC,KAAK,EAAE,GAAG,CAAA;gBAKZ,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,KAAK;IAYxE,QAAQ,CAAC,aAAa,IAAI,IAAI;IAE9B,QAAQ,CAAC,KAAK,EAAE,GAAG;IAInB;;OAEG;IACU,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhD;;OAEG;IACH,QAAQ,CAAC,QAAQ,IAAI,GAAG;IAExB,cAAc,IAAI,GAAG;IAIrB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,QAAQ,CAAC,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAE9C;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAY1C,eAAe;;;;;;;;;;IAaf,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,aAAa,IAAI,OAAO;CAa3B;AAED,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAGpE,eAAO,MAAM,qBAAqB,+CAA8B,CAAA;AAEhE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;IAM9B;;;;OAIG;;IAEH;;;;OAIG;;kBAEL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,iBAAiB,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAC1G,iBAAiB,CAAA;AAErB;;GAEG;AACH,UAAU,QAAQ,CAAC,KAAK,SAAS,SAAS,CAAE,SAAQ,eAAe,CAAC,EAAE,CAAC;IACnE,IAAI,EAAE,KAAK,CAAA;CACd"}

package/dist/core/fields/field.js

@@ -0,0 +1,148 @@
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+/**
+ * The Field class is used in the submit class to handle submission of the field
+ * It might also be used in the field factory to create the field in the form?
+ */
+export class Field {
+    static [entityKind] = 'Field';
+    type;
+    name;
+    label;
+    required;
+    /**
+     *  The default value of the field in the DB table,
+     */
+    defaultValue;
+    order;
+    groupId;
+    conditionalRules;
+    /**
+     * adminGenerated is used to determine if the field is generated by the admin or not.
+     * If set to false, the field will not be included in the form.
+     * If set to 'readonly', the field will be visible in the form as a `readonly` text, but will not be included in the submission.
+     */
+    adminGenerated;
+    /**
+     * Destination tables are used to save the value of the field in a different table.
+     * This is useful when we have a select multiple field, or a tags field and we want to save the values in a different table.
+     *
+     * Destination tables store only two identifier fields per row:
+     * - The reference item identifier: The identifier of the item that has this field as a field
+     * - The option identifier: The identifier of the select multiple or tags fields
+     *
+     * Destination tables have no identifier field.
+     * The primary key is automatically set as the combination of the reference item identifier and the option identifier.
+     */
+    destinationDb;
+    /**
+     * Dynamically generated fields based on the value of `conditionalRules` from conditional fields.
+     */
+    conditionalFields = [];
+    /*protected*/ value;
+    // No need to access the config
+    // protected config: BaseFieldConfig<TExtraFieldConfig>
+    constructor(config, fieldType) {
+        this.type = fieldType;
+        this.name = config.name;
+        this.label = config.label ?? Field.generateLabel(config.name);
+        this.required = config.required ?? false;
+        this.defaultValue = config.defaultValue;
+        this.order = config.order;
+        this.conditionalRules = config.conditionalRules;
+        this.adminGenerated = config.adminGenerated ?? true;
+        this.value = undefined;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    /**
+     * Perform any action after submitting the form
+     */
+    async postSubmit(variable) {
+        return;
+    }
+    async postSubmitRollback() {
+        return;
+    }
+    getSubmitValue() {
+        return this.getValue();
+    }
+    /**
+     * Build the field to be used in a form
+     */
+    async build() {
+        return;
+    }
+    /**
+     * Generate a human-readable label from a field name.
+     * This is a static method to avoid recreation on every call.
+     */
+    static generateLabel(name) {
+        return (name
+            // Replace underscores with spaces
+            .replace(/_/g, ' ')
+            // Insert space before camelCase capitals
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            // Capitalize first letter of each word
+            .replace(/\b\w/g, (char) => char.toUpperCase()));
+    }
+    exportForClient() {
+        return {
+            type: this.type,
+            name: this.name,
+            label: this.label,
+            required: this.required,
+            conditionalFields: this.conditionalFields,
+            readonly: this.adminGenerated === 'readonly',
+            defaultValue: this.defaultValue,
+            value: this.value,
+        };
+    }
+    hasSqlNameAndValue() {
+        return this.adminGenerated === true;
+    }
+    /**
+     * Check if field is conditional
+     */
+    isConditional() {
+        let status = true;
+        if (this.conditionalRules && this.conditionalRules.length > 0) {
+            this.conditionalRules.map((rule) => {
+                if (!rule.field || !rule.value || !rule.condition) {
+                    return (status = false);
+                }
+            });
+        }
+        else {
+            status = false;
+        }
+        return status;
+    }
+}
+// Schema for ConditionalRule (circular dependency with FieldConfig, so use custom)
+export const conditionalRuleSchema = z.custom();
+/**
+ * Base field configuration schema
+ * This schema defines the base properties that all fields share
+ * Field types should extend this schema with their specific config
+ */
+export const baseFieldConfigSchema = z.strictObject({
+    name: z.string().describe('The name of the field'),
+    label: z.string().optional().describe('The label of the field'),
+    required: z.boolean().optional().describe('Whether the field is required'),
+    defaultValue: z.any().optional().describe('The default value of the field'),
+    order: z.number().optional().describe('The order of the field'),
+    /**
+     * Set if the field is only visible when all conditions are met.
+     * For now, conditionalRules only support one condition rule.
+     * If the condition is met, the field will be visible.
+     */
+    conditionalRules: z.array(conditionalRuleSchema).optional().describe('Conditional rules for the field'),
+    /**
+     * adminGenerated is used to determine if the field is generated by the admin or not.
+     * If set to false, the field will not be included in the form.
+     * If set to 'readonly', the field will be visible in the form as a `readonly` text, but will not be included in the submission.
+     */
+    adminGenerated: z.union([z.literal(true), z.literal(false), z.literal('readonly')]).optional(),
+});

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

@@ -0,0 +1,15 @@
+import { Field } from './field';
+import { entityKind } from '../helpers';
+type FileType = 'photo' | 'video' | 'document';
+export declare abstract class FileField<TType extends FileType = FileType, TExtraFieldConfig extends object = object> extends Field<TType, TExtraFieldConfig> {
+    static readonly [entityKind]: string;
+    abstract extensions: string[];
+    /**
+     * Write the file to the disk
+     */
+    abstract writeToFile(): Promise<void>;
+    abstract setFileName(value: string): void;
+    abstract setFile(file: File): void;
+}
+export {};
+//# sourceMappingURL=fileField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fileField.d.ts","sourceRoot":"","sources":["../../../src/core/fields/fileField.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC,KAAK,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAA;AAC9C,8BAAsB,SAAS,CAC3B,KAAK,SAAS,QAAQ,GAAG,QAAQ,EACjC,iBAAiB,SAAS,MAAM,GAAG,MAAM,CAC3C,SAAQ,KAAK,CAAC,KAAK,EAAE,iBAAiB,CAAC;IACrC,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAc;IAC3D,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAA;IAC7B;;OAEG;IACH,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IACrC,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IACzC,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CACrC"}

package/dist/core/fields/fileField.js

@@ -0,0 +1,5 @@
+import { Field } from './field';
+import { entityKind } from '../helpers';
+export class FileField extends Field {
+    static [entityKind] = 'FileField';
+}

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

@@ -0,0 +1,65 @@
+export { TextField, textField } from './text';
+export type { TextFieldClientConfig, TextFieldConfig } from './text';
+export { PasswordField, passwordField } from './password';
+export type { PasswordFieldClientConfig, PasswordFieldConfig } from './password';
+export { TextAreaField, textAreaField } from './textArea';
+export type { TextAreaFieldClientConfig, TextAreaFieldConfig } from './textArea';
+export { NumberField, numberField } from './number';
+export type { NumberFieldClientConfig, NumberFieldConfig as NumberFieldConfigType } from './number';
+export { TagsField, tagsField } from './tags';
+export type { TagsFieldClientConfig, TagsFieldConfig } from './tags';
+export { PhotoField, photoField } from './photo';
+export type { PhotoFieldClientConfig, PhotoFieldConfig as PhotoFieldConfigType } from './photo';
+export { VideoField, videoField } from './video';
+export type { VideoFieldClientConfig, VideoFieldConfig } from './video';
+export { CheckboxField, checkboxField } from './checkbox';
+export type { CheckboxFieldClientConfig, CheckboxFieldConfig } from './checkbox';
+export { SelectField, selectField } from './select';
+export type { SelectFieldClientConfig, SelectFieldConfigType, SelectOption } from './select';
+export { SelectMultipleField, selectMultipleField } from './selectMultiple';
+export type { SelectMultipleFieldClientConfig, SelectMultipleFieldConfigType } from './selectMultiple';
+export { DocumentField, documentField } from './document';
+export type { DocumentFieldClientConfig, DocumentFieldConfig as DocumentFieldConfigType } from './document';
+export { MapField, mapField } from './map';
+export type { MapFieldClientConfig, MapFieldConfig } from './map';
+export { RichTextField, richTextField } from './richText';
+export type { RichTextFieldClientConfig, RichTextFieldConfig as RichTextFieldConfigType } from './richText';
+export { DateField, dateField } from './date';
+export type { DateFieldClientConfig, DateFieldConfig } from './date';
+export { ColorField, colorField } from './color';
+export type { ColorFieldClientConfig, ColorFieldConfig } from './color';
+export { Field } from './field';
+export type { BaseFieldConfig, FieldClientConfig } from './field';
+export { FileField } from './fileField';
+export { fieldGroup } from './field-group';
+export type { FieldGroup, FieldGroupOptions, FieldGroupConfig } from './field-group';
+import type { TextFieldConfig } from './text';
+import type { NumberFieldConfig } from './number';
+import type { TextAreaFieldConfig } from './textArea';
+import type { TagsFieldConfig } from './tags';
+import type { CheckboxFieldConfig } from './checkbox';
+import type { RichTextFieldConfig } from './richText';
+import type { PasswordFieldConfig } from './password';
+import type { PhotoFieldConfig } from './photo';
+import type { VideoFieldConfig } from './video';
+import type { SelectFieldConfigType } from './select';
+import type { SelectMultipleFieldConfigType } from './selectMultiple';
+import type { DocumentFieldConfig } from './document';
+import type { MapFieldConfig } from './map';
+import type { DateFieldConfig } from './date';
+import type { ColorFieldConfig } from './color';
+/**
+ * Union type of all field config types
+ * This allows type-safe handling of field configs
+ *
+ * Each field config has a build() method that creates a Field instance.
+ * Use the build() method directly on the config: `fieldConfig.build()`
+ *
+ * @example
+ * ```typescript
+ * const textConfig = textField({ name: 'title', label: 'Title' })
+ * const textInstance = textConfig.build() // Direct build() call
+ * ```
+ */
+export type FieldConfig = TextFieldConfig | NumberFieldConfig | TextAreaFieldConfig | TagsFieldConfig | CheckboxFieldConfig | RichTextFieldConfig | PasswordFieldConfig | PhotoFieldConfig | VideoFieldConfig | SelectFieldConfigType | SelectMultipleFieldConfigType | DocumentFieldConfig | MapFieldConfig | DateFieldConfig | ColorFieldConfig;
+//# sourceMappingURL=index.d.ts.map