nextjs-cms 0.5.9 → 0.5.10

package/dist/core/fields/document.js

@@ -1,277 +1,277 @@
-import { baseFieldConfigSchema } from "./field.js";
-import { entityKind } from "../helpers.js";
-import * as z from 'zod';
-import fs from 'fs';
-import { customAlphabet } from 'nanoid';
-import path from 'path';
-import { FileField } from "./fileField.js";
-import { getCMSConfig } from "../config.js";
-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;
-}
+import { baseFieldConfigSchema } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import * as z from 'zod';
+import fs from 'fs';
+import { customAlphabet } from 'nanoid';
+import path from 'path';
+import { FileField } from './fileField.js';
+import { getCMSConfig } from '../config/index.js';
+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

@@ -1,18 +1,18 @@
-import type { Field, FieldConfig } from "..js";
-import type { Prettify } from "../types.js";
-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;
+import type { Field, FieldConfig } from './index.js';
+import type { Prettify } from '../types/index.js';
+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

@@ -1 +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"}
+{"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,YAAY,CAAA;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD,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

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