nextjs-cms 0.0.1 → 0.5.1

package/dist/core/sections/category.d.ts

@@ -0,0 +1,283 @@
+import type { BaseSectionOptions } from './section';
+import type { FieldGroupConfig } from '../fields/field-group';
+import { Section } from './section';
+import type { TextFieldConfig } from '../fields';
+import { entityKind } from '../helpers';
+import type { FieldConfig } from '../fields';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    headingField: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+    title: z.ZodObject<{
+        section: z.ZodString;
+        singular: z.ZodString;
+        plural: z.ZodString;
+    }, z.core.$strict>;
+    /**
+     * The depth of the category section is the number of nested levels of categories that can be created.
+     * For example, if the depth is 2, each category can have one subcategory.
+     * Default value is 1. (No subcategories)
+     */
+    depth: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Allow recursive delete of categories children (depth > 1) when deleting the parent category.
+     * If true, all children categories will be deleted when the parent category is deleted.
+     * For this to take effect, `allowRecursiveDelete` in lz.config.ts must also be set to true.
+     * @default false
+     */
+    allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class CategorySection extends Section<Config> {
+    static readonly [entityKind] = "CategorySection";
+    readonly type = "category";
+    readonly title: {
+        section: string;
+        singular: string;
+        plural: string;
+    };
+    readonly headingField: TextFieldConfig;
+    readonly depth: number;
+    readonly allowRecursiveDelete: boolean;
+    constructor(config: BaseSectionOptions<Config>);
+}
+declare const optionsSchema: z.ZodObject<{
+    headingField: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+    title: z.ZodObject<{
+        section: z.ZodString;
+        singular: z.ZodString;
+        plural: z.ZodString;
+    }, z.core.$strict>;
+    /**
+     * The depth of the category section is the number of nested levels of categories that can be created.
+     * For example, if the depth is 2, each category can have one subcategory.
+     * Default value is 1. (No subcategories)
+     */
+    depth: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Allow recursive delete of categories children (depth > 1) when deleting the parent category.
+     * If true, all children categories will be deleted when the parent category is deleted.
+     * For this to take effect, `allowRecursiveDelete` in lz.config.ts must also be set to true.
+     * @default false
+     */
+    allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").Variant, import("../types").Variant>>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    db: z.ZodObject<{
+        table: z.ZodString;
+        identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
+        orderByField: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
+        primaryKey: z.ZodOptional<z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>>;
+        foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            foreignColumns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        index: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        unique: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        fulltext: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    icon: z.ZodOptional<z.ZodString>;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodCustom<import("./section").Hooks, import("./section").Hooks>>;
+}, z.core.$strict>;
+export declare const categorySectionConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"category">;
+    fields: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<CategorySection, CategorySection>>;
+    fieldGroups: z.ZodOptional<z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>>;
+    headingField: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("..").TextField, import("..").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+    title: z.ZodObject<{
+        section: z.ZodString;
+        singular: z.ZodString;
+        plural: z.ZodString;
+    }, z.core.$strict>;
+    /**
+     * The depth of the category section is the number of nested levels of categories that can be created.
+     * For example, if the depth is 2, each category can have one subcategory.
+     * Default value is 1. (No subcategories)
+     */
+    depth: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Allow recursive delete of categories children (depth > 1) when deleting the parent category.
+     * If true, all children categories will be deleted when the parent category is deleted.
+     * For this to take effect, `allowRecursiveDelete` in lz.config.ts must also be set to true.
+     * @default false
+     */
+    allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").Variant, import("../types").Variant>>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    db: z.ZodObject<{
+        table: z.ZodString;
+        identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
+        orderByField: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
+        primaryKey: z.ZodOptional<z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>>;
+        foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            foreignColumns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        index: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        unique: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        fulltext: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    icon: z.ZodOptional<z.ZodString>;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodCustom<import("./section").Hooks, import("./section").Hooks>>;
+}, z.core.$strict>;
+export type CategorySectionOptions = z.infer<typeof optionsSchema>;
+/**
+ * Category section configuration
+ * This is the output of the categorySection() helper function, it that can be serialized and used anywhere
+ * The build() method allows creating a CategorySection instance when needed
+ */
+export type CategorySectionConfig = z.infer<typeof categorySectionConfigSchema>;
+/**
+ * Helper function to create a category section configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const sectionConfig = categorySection({ name: 'categories', ... })
+ * const sectionInstance = sectionConfig.build()
+ * ```
+ *
+ * @param section
+ */
+export declare function categorySection(section: CategorySectionOptions): CategorySectionConfig;
+export {};
+//# sourceMappingURL=category.d.ts.map

package/dist/core/sections/category.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"category.d.ts","sourceRoot":"","sources":["../../../src/core/sections/category.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,OAAO,EAA8E,MAAM,WAAW,CAAA;AAC/G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWd;;;;OAIG;;IAEH;;;;;OAKG;;kBAGL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,eAAgB,SAAQ,OAAO,CAAC,MAAM,CAAC;IAChD,gBAAyB,CAAC,UAAU,CAAC,qBAAoB;IACzD,SAAkB,IAAI,cAAa;IACnC,SAAkB,KAAK,EAAE;QACrB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IACD,QAAQ,CAAC,YAAY,EAAE,eAAe,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAI;IAC1B,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;gBAE1B,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC;CA0CjD;AAED,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA1Ef;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkEL,CAAA;AAOF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApFpC;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiFL,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAElE;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CA6CtF"}

package/dist/core/sections/category.js

@@ -0,0 +1,147 @@
+import { Section, baseHelperFunctionOptionsSchema, FieldGroupConfigSchema, fieldConfigSchema } from './section';
+import { entityKind } from '../helpers';
+import { numberField, textField } from '../fields';
+import * as z from 'zod';
+const configSchema = z.strictObject({
+    headingField: z
+        .custom()
+        .describe('Heading field must be a config - will be resolved during instantiation'),
+    title: z
+        .strictObject({
+        section: z.string().describe('The section title'),
+        singular: z.string().describe('The singular form of the title'),
+        plural: z.string().describe('The plural form of the title'),
+    })
+        .describe('The title configuration for the category section'),
+    /**
+     * The depth of the category section is the number of nested levels of categories that can be created.
+     * For example, if the depth is 2, each category can have one subcategory.
+     * Default value is 1. (No subcategories)
+     */
+    depth: z.number().positive().optional().describe('The depth of the category section'),
+    /**
+     * Allow recursive delete of categories children (depth > 1) when deleting the parent category.
+     * If true, all children categories will be deleted when the parent category is deleted.
+     * For this to take effect, `allowRecursiveDelete` in lz.config.ts must also be set to true.
+     * @default false
+     */
+    allowRecursiveDelete: z.boolean().optional().describe('Allow recursive delete of categories children'),
+    // requirePublishPermission?: boolean
+});
+export class CategorySection extends Section {
+    static [entityKind] = 'CategorySection';
+    type = 'category';
+    title;
+    headingField;
+    depth = 1;
+    allowRecursiveDelete;
+    // private requirePublishPermission: boolean
+    constructor(config) {
+        super(config);
+        this.title = config.title;
+        this.depth = config.depth ?? 1;
+        this.headingField = config.headingField;
+        this.allowRecursiveDelete = config.allowRecursiveDelete ?? false;
+        // this.requirePublishPermission = config.requirePublishPermission
+        /**
+         * Add the parentId and level fields to the fields if the depth is greater than 1
+         * Make sure to match the identifier field type
+         */
+        if (this.depth > 1) {
+            const levelConfig = numberField({
+                name: 'level',
+                label: 'Level',
+                required: false,
+                order: 0,
+            });
+            if (this.db.identifier.type === 'number') {
+                this._fieldConfigs?.push(numberField({
+                    name: 'parent_id',
+                    label: 'Parent ID',
+                    required: false,
+                    order: 0,
+                }), levelConfig);
+            }
+            else if (this.db.identifier.type === 'text') {
+                this._fieldConfigs?.push(textField({
+                    name: 'parent_id',
+                    label: 'Parent ID',
+                    required: false,
+                    order: 0,
+                }), levelConfig);
+            }
+        }
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseHelperFunctionOptionsSchema.shape,
+    ...configSchema.shape,
+});
+const compiledOptionsSchema = z.strictObject({
+    ...optionsSchema.shape,
+    fieldGroups: z.array(FieldGroupConfigSchema).optional().describe('The field groups of the section if provided'),
+});
+export const categorySectionConfigSchema = z.strictObject({
+    ...compiledOptionsSchema.shape,
+    type: z.literal('category').describe('The type of the section'),
+    fields: z.array(fieldConfigSchema).describe('The fields of the section'),
+    build: z
+        .function()
+        .output(z.instanceof(CategorySection))
+        .describe('Build a CategorySection instance from this config'),
+});
+/**
+ * Helper function to create a category section configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const sectionConfig = categorySection({ name: 'categories', ... })
+ * const sectionInstance = sectionConfig.build()
+ * ```
+ *
+ * @param section
+ */
+export function categorySection(section) {
+    /**
+     * Validate the section config
+     */
+    const result = optionsSchema.safeParse(section);
+    if (!result.success) {
+        throw new Error(`[Section: ${section.name}]: ${z.prettifyError(result.error)}`);
+    }
+    /**
+     * Resolve fields and fieldGroups
+     */
+    let fields = [];
+    let fieldGroups = [];
+    if (section.fields && section.fields.length > 0) {
+        const firstInput = section.fields[0];
+        /**
+         * Check if the first item is a field group.
+         * We don't need to check every item,
+         * because zod already validated the fields array.
+         */
+        if (firstInput && 'fields' in firstInput) {
+            fieldGroups = section.fields;
+            fields = fieldGroups.flatMap((group) => group.fields);
+        }
+        else {
+            fields = section.fields;
+        }
+    }
+    const config = {
+        ...section,
+        fields,
+        fieldGroups: fieldGroups.length > 0 ? fieldGroups : undefined,
+        type: 'category',
+        build() {
+            return new CategorySection({
+                ...section,
+                fields,
+                fieldGroups: fieldGroups.length > 0 ? fieldGroups : undefined,
+            });
+        },
+    };
+    return config;
+}