nextjs-cms 0.0.1 → 0.5.2

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

@@ -0,0 +1,289 @@
+import type { BaseFieldConfig } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import { FileField } from './fileField';
+declare const configSchema: z.ZodObject<{
+    /** Whether to add watermark to images */
+    watermark: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    blurPlaceholder: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        /**
+         * @true The image will not have dimensions constraints,
+         * and will be cropped to fit the specified dimensions
+         *
+         * @false The user will be forced to upload an image with the specified dimensions
+         *
+         * @example
+         * size: {
+         *   width: 1200,
+         *   height: 450,
+         *   crop: true, // No constraints
+         *   }
+         */
+        crop: z.ZodBoolean;
+    }, z.core.$strict>>;
+    thumbnail: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        crop: z.ZodBoolean;
+        quality: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    /**
+     * Maximum file size
+     * @example
+     * maxFileSize: {
+     *    size: 512,
+     *    unit: 'kb',
+     *    }
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, z.core.$strict>>;
+    /**
+     * Allowed image types
+     * @example
+     * type: ['jpeg', 'png', 'webp']
+     * @default ['jpeg']
+     * @link https://sharp.pixelplumbing.com/api-output#toformat
+     * @hint 'jpg' is an alias for 'jpeg'
+     */
+    type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        webp: "webp";
+        jpg: "jpg";
+        jpeg: "jpeg";
+        png: "png";
+    }>>>;
+    /**
+     * Remove the extension from the file name
+     * @default true
+     */
+    removeExtension: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class PhotoField extends FileField<'photo', Config> {
+    static readonly [entityKind]: string;
+    readonly watermark: boolean | null | undefined;
+    readonly blurPlaceholder: boolean | null | undefined;
+    readonly size: {
+        width: number;
+        height: number;
+        crop: boolean;
+    } | undefined;
+    readonly maxFileSize: {
+        size: number;
+        unit: 'kb' | 'mb';
+    };
+    readonly mimeType: string[];
+    readonly extensions: string[];
+    readonly thumbnail: {
+        width: number;
+        height: number;
+        crop: boolean;
+        quality?: number;
+    };
+    readonly removeExtension: boolean;
+    readonly uploadsFolder: string;
+    /**
+     * _file is the file object if it's present
+     * Whereas the value is the path to the file
+     */
+    private _file;
+    private _sharpImage;
+    private _folder;
+    private _allowedExtensions;
+    constructor(config: BaseFieldConfig<Config>, file?: File);
+    exportForClient(): {
+        thumbnail: {
+            width: number;
+            height: number;
+            crop: boolean;
+            quality?: number;
+        };
+        size: {
+            width: number;
+            height: number;
+            crop: boolean;
+        } | undefined;
+        maxFileSize: {
+            size: number;
+            unit: "kb" | "mb";
+        };
+        extensions: string[];
+        mimeType: string[];
+        type: "photo";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    /**
+     * Write the file to the disk
+     */
+    writeToFile(): Promise<void>;
+    postSubmit(folder: string): Promise<void>;
+    postSubmitRollback(): Promise<void>;
+    /**
+     * Get the value of the field
+     */
+    getValue(): string;
+    setFileName(value: string): void;
+    setValue(value: any): void;
+    setFile(file: File): void;
+    checkRequired(): void;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type PhotoFieldClientConfig = ReturnType<PhotoField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    /** Whether to add watermark to images */
+    watermark: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    blurPlaceholder: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        /**
+         * @true The image will not have dimensions constraints,
+         * and will be cropped to fit the specified dimensions
+         *
+         * @false The user will be forced to upload an image with the specified dimensions
+         *
+         * @example
+         * size: {
+         *   width: 1200,
+         *   height: 450,
+         *   crop: true, // No constraints
+         *   }
+         */
+        crop: z.ZodBoolean;
+    }, z.core.$strict>>;
+    thumbnail: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        crop: z.ZodBoolean;
+        quality: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    /**
+     * Maximum file size
+     * @example
+     * maxFileSize: {
+     *    size: 512,
+     *    unit: 'kb',
+     *    }
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, z.core.$strict>>;
+    /**
+     * Allowed image types
+     * @example
+     * type: ['jpeg', 'png', 'webp']
+     * @default ['jpeg']
+     * @link https://sharp.pixelplumbing.com/api-output#toformat
+     * @hint 'jpg' is an alias for 'jpeg'
+     */
+    type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        webp: "webp";
+        jpg: "jpg";
+        jpeg: "jpeg";
+        png: "png";
+    }>>>;
+    /**
+     * Remove the extension from the file name
+     * @default true
+     */
+    removeExtension: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const photoFieldConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"photo">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<PhotoField, PhotoField>>;
+    /** Whether to add watermark to images */
+    watermark: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    blurPlaceholder: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        /**
+         * @true The image will not have dimensions constraints,
+         * and will be cropped to fit the specified dimensions
+         *
+         * @false The user will be forced to upload an image with the specified dimensions
+         *
+         * @example
+         * size: {
+         *   width: 1200,
+         *   height: 450,
+         *   crop: true, // No constraints
+         *   }
+         */
+        crop: z.ZodBoolean;
+    }, z.core.$strict>>;
+    thumbnail: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        crop: z.ZodBoolean;
+        quality: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    /**
+     * Maximum file size
+     * @example
+     * maxFileSize: {
+     *    size: 512,
+     *    unit: 'kb',
+     *    }
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, z.core.$strict>>;
+    /**
+     * Remove the extension from the file name
+     * @default true
+     */
+    removeExtension: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Photo field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a PhotoField instance when needed
+ */
+export type PhotoFieldConfig = z.infer<typeof photoFieldConfigSchema>;
+/**
+ * Helper function to create a photo field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export declare function photoField(field: z.infer<typeof optionsSchema>): PhotoFieldConfig;
+export {};
+//# sourceMappingURL=photo.d.ts.map

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

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

package/dist/core/fields/photo.js

@@ -0,0 +1,410 @@
+import { baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import sharp from 'sharp';
+import path from 'path';
+import fs from 'fs';
+import { customAlphabet } from 'nanoid';
+import { FileField } from './fileField';
+import { humanReadableFileSize } from '../../utils';
+import { getCMSConfig } from '../config';
+const cmsConfig = getCMSConfig();
+const sizeSchema = z.strictObject({
+    width: z.number().describe('Image width in pixels'),
+    height: z.number().describe('Image height in pixels'),
+    /**
+     * @true The image will not have dimensions constraints,
+     * and will be cropped to fit the specified dimensions
+     *
+     * @false The user will be forced to upload an image with the specified dimensions
+     *
+     * @example
+     * size: {
+     *   width: 1200,
+     *   height: 450,
+     *   crop: true, // No constraints
+     *   }
+     */
+    crop: z.boolean().describe('Whether to crop the image to fit dimensions'),
+});
+const thumbnailSchema = z.strictObject({
+    width: z.number().describe('Thumbnail width in pixels'),
+    height: z.number().describe('Thumbnail height in pixels'),
+    crop: z.boolean().describe('Whether to crop the thumbnail'),
+    quality: z.number().optional().describe('Thumbnail quality (0-100)'),
+});
+const maxFileSizeSchema = z.strictObject({
+    size: z.number().describe('Maximum file size'),
+    unit: z.enum(['kb', 'mb']).describe('Size unit'),
+});
+const configSchema = z.strictObject({
+    /** Whether to add watermark to images */
+    watermark: z.boolean().nullable().optional(),
+    blurPlaceholder: z.boolean().nullable().optional(),
+    size: sizeSchema.optional(),
+    thumbnail: thumbnailSchema.optional(),
+    /**
+     * Maximum file size
+     * @example
+     * maxFileSize: {
+     *    size: 512,
+     *    unit: 'kb',
+     *    }
+     */
+    maxFileSize: maxFileSizeSchema.optional(),
+    /**
+     * Allowed image types
+     * @example
+     * type: ['jpeg', 'png', 'webp']
+     * @default ['jpeg']
+     * @link https://sharp.pixelplumbing.com/api-output#toformat
+     * @hint 'jpg' is an alias for 'jpeg'
+     */
+    type: z.array(z.enum(['jpeg', 'jpg', 'png', 'webp'])).optional(),
+    /**
+     * Remove the extension from the file name
+     * @default true
+     */
+    removeExtension: z.boolean().optional(),
+});
+export class PhotoField extends FileField {
+    static [entityKind] = 'PhotoField';
+    watermark;
+    blurPlaceholder;
+    size;
+    maxFileSize;
+    mimeType;
+    extensions;
+    thumbnail;
+    removeExtension;
+    uploadsFolder = cmsConfig.files.upload.uploadPath;
+    /**
+     * _file is the file object if it's present
+     * Whereas the value is the path to the file
+     */
+    _file = undefined;
+    _sharpImage = undefined;
+    _folder;
+    _allowedExtensions;
+    constructor(config, file) {
+        super(config, 'photo');
+        if (file) {
+            this._file = file;
+        }
+        this.watermark = config.watermark;
+        this.blurPlaceholder = config.blurPlaceholder;
+        this.size = config.size;
+        this.maxFileSize = config.maxFileSize ?? { size: 2, unit: 'mb' };
+        this.thumbnail = config.thumbnail ?? cmsConfig.files.images.thumbnail;
+        this.removeExtension = config.removeExtension ?? true;
+        this.extensions = config.type ?? ['jpeg'];
+        /**
+         * Replace 'jpg' with 'jpeg'
+         */
+        this.extensions = this.extensions.map((e) => (e === 'jpg' ? 'jpeg' : e));
+        /**
+         * Extract the mime types from the extensions
+         */
+        this.mimeType = this.extensions.map((e) => {
+            if (e === 'jpeg')
+                return 'image/jpeg';
+            if (e === 'png')
+                return 'image/png';
+            if (e === 'webp')
+                return 'image/webp';
+            throw new Error(`Invalid image extension provided: ${e}`);
+        });
+        /**
+         * Set the allowed extensions, add jpg if jpeg is present
+         */
+        this._allowedExtensions = this.extensions;
+        if (this.extensions.includes('jpeg')) {
+            this._allowedExtensions.push('jpg');
+        }
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            thumbnail: this.thumbnail,
+            // watermark: this.watermark,
+            // blurPlaceholder: this.blurPlaceholder,
+            size: this.size,
+            maxFileSize: this.maxFileSize,
+            extensions: this._allowedExtensions,
+            mimeType: this.mimeType,
+        };
+    }
+    /**
+     * 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 calling postSubmit() before writing the file to disk`);
+        }
+        if (!this._sharpImage) {
+            throw new Error(`${this.label}: Image is not set. Make sure to call prepareForSubmission() before writing the file to disk`);
+        }
+        try {
+            /**
+             * If .photos, and 'sectionName' folders don't exist, create them
+             */
+            const photosFolder = path.join(this.uploadsFolder, '.photos', this._folder);
+            const thumbsFolder = path.join(this.uploadsFolder, '.thumbs', this._folder);
+            if (!fs.existsSync(photosFolder)) {
+                fs.mkdirSync(photosFolder, { recursive: true });
+            }
+            if (!fs.existsSync(thumbsFolder)) {
+                fs.mkdirSync(thumbsFolder, { recursive: true });
+            }
+            /**
+             * Check if the image needs to be resized and write the file to disk
+             */
+            if (this.size && this.size.crop) {
+                await this._sharpImage
+                    .clone()
+                    .resize({
+                    width: this.size.width,
+                    height: this.size.height,
+                    fit: 'cover',
+                })
+                    .webp()
+                    .toFile(path.join(this.uploadsFolder, '.photos', this._folder, this.value));
+            }
+            else {
+                await this._sharpImage
+                    .clone()
+                    .toFile(path.join(this.uploadsFolder, '.photos', this._folder, this.value));
+            }
+            /**
+             * Also, write a thumbnail
+             */
+            await this._sharpImage
+                .clone()
+                .resize({
+                width: this.thumbnail.width,
+                height: this.thumbnail.height,
+                fit: this.thumbnail.crop ? 'cover' : 'contain',
+            })
+                .webp({
+                quality: this.thumbnail.quality || 80,
+            })
+                .toFile(path.join(this.uploadsFolder, '.thumbs', this._folder, this.value));
+        }
+        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, '.photos', 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
+         */
+        if (this.required) {
+            if (!this._file?.type || !this._file?.name || !this._file?.size) {
+                throw new Error(`Field ${this.label} is required`);
+            }
+        }
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        /**
+         * Check if the file is present
+         */
+        if (!this._file)
+            return;
+        /**
+         * Check extension
+         */
+        let ext = this._file.name.split('.').pop();
+        // Treat jpg as jpeg
+        if (ext === 'jpg')
+            ext = 'jpeg';
+        if (!ext || !this.extensions.includes(ext)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Construct the image
+         */
+        const arrayBuffer = await this._file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        /**
+         * Check mime type
+         */
+        if (!this.mimeType.includes(this._file.type)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Check actual mime type
+         */
+        const { fileTypeFromBuffer } = await import('file-type');
+        const actualMimeType = await fileTypeFromBuffer(buffer);
+        if (!actualMimeType ||
+            !this.extensions.includes(actualMimeType.ext) ||
+            !this.mimeType.includes(actualMimeType.mime)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Disable caching for the image to avoid unlink issues
+         */
+        sharp.cache({ files: 0 });
+        sharp.cache(false);
+        const image = sharp(buffer);
+        /**
+         * Get the metadata
+         * Fast access to (uncached) image metadata without decoding any compressed pixel data.
+         * This is read from the header of the input image.
+         * It does not take into consideration any operations to be applied to the output image, such as resize or rotate.
+         * @link: https://sharp.pixelplumbing.com/api-input#metadata
+         */
+        const metadata = await image.metadata();
+        /**
+         * Check the actual file size (buffer size)
+         */
+        const fileSize = buffer.length;
+        if (!fileSize || !metadata.size) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+        /**
+         * Check the file size
+         */
+        if (fileSize > this.maxFileSize.size * (this.maxFileSize.unit === 'kb' ? 1024 : 1024 * 1024)) {
+            throw new Error(`${this.label}: File size (${humanReadableFileSize(fileSize)}) exceeds the maximum allowed size of ${this.maxFileSize.size} ${this.maxFileSize.unit}`);
+        }
+        /**
+         * Don't just trust the file extension
+         * Check the format
+         */
+        if (!metadata.format || !this.extensions.includes(metadata.format)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Check stat
+         */
+        try {
+            await image.stats();
+        }
+        catch (error) {
+            throw new Error(`File is corrupted`);
+        }
+        /**
+         * Convert the image to webp
+         */
+        try {
+            image.toFormat('webp').withExif({});
+        }
+        catch (error) {
+            throw new Error(`File is corrupted`);
+        }
+        /**
+         * Check the size
+         */
+        if (this.size) {
+            /**
+             * Check if the image does not need to be cropped (dimensions are constrained)
+             */
+            if (!this.size.crop) {
+                /**
+                 * Just resize the image?
+                 */
+                /**
+                 * Check if the size matches the required size
+                 */
+                if (metadata.width !== this.size.width || metadata.height !== this.size.height) {
+                    throw new Error(`${this.label}: Uploaded image size (${metadata.width}x${metadata.height} pixels) does not match the required size: ${this.size.width}x${this.size.height} pixels`);
+                }
+            }
+        }
+        /**
+         * Generate a random name for the file
+         */
+        this.value = customAlphabet('1234567890abcdef', 21)();
+        this.value = this.removeExtension ? this.value : this.value + '.webp';
+        /*if (saveFilesWithExtensions) {
+            /!**
+             * Currently we're forcing webp output.
+             * I've to add the ability for developers to choose the output format
+             *!/
+            this.value += '.webp'
+        }*/
+        /**
+         * Set the sharp image
+         */
+        this._sharpImage = image;
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const photoFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('photo').describe('The type of the field'),
+    build: z.function().output(z.instanceof(PhotoField)).describe('Build a PhotoField instance from this config'),
+});
+/**
+ * Helper function to create a photo field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function photoField(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: 'photo',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new PhotoField(field);
+        },
+    };
+    return config;
+}