rimecms 0.22.0

package/dist/core/collections/config/augment-title.d.ts

@@ -0,0 +1,16 @@
+import type { CollectionAuthConfig, UploadConfig } from '../../config/types.js';
+import type { Collection } from '../../../types.js';
+type Input = {
+    upload?: UploadConfig;
+    auth?: false | CollectionAuthConfig;
+    fields: Collection<any>['fields'];
+};
+type WithAsTitle<T> = T & {
+    asTitle: string;
+};
+/**
+ * Set asTitle to the defined one, or fallback to
+ * filename for upload, email for auth, or default to id
+ */
+export declare const augmentTitle: <T extends Input>(config: T) => WithAsTitle<T>;
+export {};

package/dist/core/collections/config/augment-title.js

@@ -0,0 +1,27 @@
+import { findTitleField } from '../../config/shared/find-title.js';
+/**
+ * Set asTitle to the defined one, or fallback to
+ * filename for upload, email for auth, or default to id
+ */
+export const augmentTitle = (config) => {
+    const addAsTitle = () => {
+        const titleField = findTitleField(config.fields);
+        switch (true) {
+            case !!titleField:
+                return titleField.path;
+            case !!config.upload:
+                return 'filename';
+            case (typeof config.auth === 'boolean' && config.auth) ||
+                (typeof config.auth !== 'boolean' && config.auth?.type === 'password'):
+                return 'email';
+            case typeof config.auth !== 'boolean' && config.auth?.type === 'apiKey':
+                return 'name';
+            default:
+                return 'id';
+        }
+    };
+    return {
+        ...config,
+        asTitle: addAsTitle()
+    };
+};

package/dist/core/collections/config/augment-upload.d.ts

@@ -0,0 +1,10 @@
+import type { UploadConfig } from '../../config/types.js';
+import type { Collection } from '../../../types.js';
+export type WithNormalizedUpload<T> = Omit<T, 'upload'> & {
+    upload?: UploadConfig;
+};
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export declare const augmentUpload: <T extends Collection<any>>(config: T) => WithNormalizedUpload<T>;

package/dist/core/collections/config/augment-upload.js

@@ -0,0 +1,58 @@
+import { text } from '../../../fields/text/index.js';
+import { toCamelCase } from '../../../util/string.js';
+import { validatePath } from '../upload/util/path.js';
+const withNormalizedUpload = (config) => {
+    // Create a new object without the auth property
+    const { upload, ...rest } = config;
+    // Determine the normalized upload value
+    let normalizedUpload;
+    if (typeof upload === 'boolean') {
+        normalizedUpload = upload === true ? {} : undefined;
+    }
+    else {
+        normalizedUpload = upload;
+    }
+    // Return the new object with the normalized upload
+    return {
+        ...rest,
+        upload: normalizedUpload
+    };
+};
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export const augmentUpload = (config) => {
+    const normalizedUploadConfig = withNormalizedUpload(config);
+    if (!normalizedUploadConfig.upload)
+        return normalizedUploadConfig;
+    const { upload } = normalizedUploadConfig;
+    let fields = [...config.fields];
+    if (upload) {
+        // Add panel thumbnail size if not already present
+        const isPanelThumbnailInSizes = upload.imageSizes && upload.imageSizes.some((size) => size.name === 'thumbnail');
+        if (!isPanelThumbnailInSizes) {
+            const thumbnailSize = { name: 'thumbnail', width: 400, compression: 60 };
+            upload.imageSizes = [thumbnailSize, ...(upload.imageSizes || [])];
+        }
+        // Add image size fields
+        if ('imageSizes' in upload && upload.imageSizes?.length) {
+            const sizesFields = upload.imageSizes.map((size) => text(toCamelCase(size.name)).hidden());
+            fields = [...fields, ...sizesFields];
+        }
+        // Add mimeType field
+        const mimeType = text('mimeType').table({ sort: true, position: 99 }).hidden();
+        // Add validation if accept is defined
+        if ('accept' in upload && Array.isArray(upload.accept)) {
+            const allowedMimeTypes = upload.accept;
+            mimeType.raw.validate = (value) => {
+                return ((typeof value === 'string' && allowedMimeTypes.includes(value)) ||
+                    `File should be the type of ${allowedMimeTypes.toString()}`);
+            };
+        }
+        const _pathField = text('_path')._root().hidden().validate(validatePath);
+        // Add hidden fields
+        fields.push(mimeType, text('filename').hidden(), text('filesize').hidden(), _pathField);
+    }
+    return { ...config, upload: upload || false, fields };
+};

package/dist/core/collections/config/augment-upload.server.d.ts

@@ -0,0 +1,7 @@
+import type { Collection } from '../../config/types.js';
+import { type WithNormalizedUpload } from './augment-upload.js';
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export declare const augmentUploadServer: <T extends Collection<any>>(config: T) => WithNormalizedUpload<T>;

package/dist/core/collections/config/augment-upload.server.js

@@ -0,0 +1,16 @@
+import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
+import { withDirectoriesSuffix } from '../../naming.js';
+import { augmentUpload } from './augment-upload.js';
+/**
+ * Normalize config.upload and imagesSizes
+ * add corresponding fields with validation if config.upload.accept is defined
+ */
+export const augmentUploadServer = (config) => {
+    const collection = augmentUpload(config);
+    collection.fields.forEach((field) => {
+        if (field instanceof FormFieldBuilder && field.name === '_path') {
+            field = field.$generateSchema(() => `_path: text('_path').references(() => ${withDirectoriesSuffix(config.slug)}.id, {onDelete: 'cascade', onUpdate: 'cascade'})`);
+        }
+    });
+    return collection;
+};

package/dist/core/collections/config/augment-url.d.ts

@@ -0,0 +1,10 @@
+import type { Collection } from '../../../types.js';
+type Input = {
+    $url?: Collection<any>['$url'];
+    fields: Collection<any>['fields'];
+};
+/**
+ * Add url field
+ */
+export declare const augmentUrl: <T extends Input>(config: T) => T;
+export {};

package/dist/core/collections/config/augment-url.js

@@ -0,0 +1,14 @@
+import { text } from '../../../fields/text/index.js';
+/**
+ * Add url field
+ */
+export const augmentUrl = (config) => {
+    let fields = [...config.fields];
+    if (config.$url) {
+        fields = [...fields, text('url').localized().hidden()];
+    }
+    return {
+        ...config,
+        fields
+    };
+};

package/dist/core/collections/config/augment-versions.d.ts

@@ -0,0 +1,14 @@
+import type { VersionsConfig } from '../../config/types.js';
+import type { Collection } from '../../../types.js';
+type Input = {
+    versions?: Collection<any>['versions'];
+    fields: Collection<any>['fields'];
+};
+type WithVersionsConfig<T> = Omit<T, 'versions'> & {
+    versions?: Required<VersionsConfig>;
+};
+/**
+ * Normalize versions prop and add status field if config.versions.draft is true
+ */
+export declare const augmentVersions: <T extends Input>(config: T) => WithVersionsConfig<T>;
+export {};

package/dist/core/collections/config/augment-versions.js

@@ -0,0 +1,24 @@
+import { VERSIONS_STATUS } from '../../constant.js';
+import { text } from '../../../fields/text/index.js';
+/**
+ * Normalize versions prop and add status field if config.versions.draft is true
+ */
+export const augmentVersions = (config) => {
+    const fields = [...config.fields];
+    const { versions, ...rest } = config;
+    let normalizedVersions;
+    if (versions) {
+        normalizedVersions = {
+            draft: typeof versions === 'boolean' ? false : (versions.draft ?? false),
+            autoSave: typeof versions === 'boolean' ? false : (versions.autoSave ?? false),
+            maxVersions: typeof versions === 'boolean' ? 12 : (versions.maxVersions ?? 12)
+        };
+        if (normalizedVersions.draft) {
+            fields.push(text('status').defaultValue(VERSIONS_STATUS.DRAFT).hidden());
+        }
+    }
+    else {
+        normalizedVersions = undefined;
+    }
+    return { ...rest, versions: normalizedVersions, fields };
+};

package/dist/core/collections/config/builder.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionWithoutSlug } from './types.js';
+import type { BuiltCollection } from '../../config/types.js';
+export declare const create: <S extends string>(slug: S, incomingConfig: CollectionWithoutSlug<S>) => BuiltCollection;

package/dist/core/collections/config/builder.js

@@ -0,0 +1,49 @@
+import { augmentAuth } from './augment-auth.js';
+import { augmentMetas } from './augment-metas.js';
+import { augmentNested } from './augment-nested.js';
+import { augmentTitle } from './augment-title.js';
+import { augmentUpload } from './augment-upload.js';
+import { augmentUrl } from './augment-url.js';
+import { augmentVersions } from './augment-versions.js';
+import { access } from '../../../util/index.js';
+import { toKebabCase } from '../../../util/string.js';
+import { FileText } from '@lucide/svelte';
+import { augmentLabel } from './augment-label.js';
+import { augmentThumbnail } from './augment-thumbnail.js';
+export const create = (slug, incomingConfig) => {
+    //
+    const collection = { ...incomingConfig, slug };
+    const initial = { ...collection };
+    const withLabel = augmentLabel(initial);
+    const withUpload = augmentUpload(withLabel);
+    const withNested = augmentNested(withUpload);
+    const withVersions = augmentVersions(withNested);
+    const withUrl = augmentUrl(withVersions);
+    const withAuth = augmentAuth(withUrl);
+    const withMetas = augmentMetas(withAuth);
+    const withTitle = augmentTitle(withMetas);
+    const augmented = augmentThumbnail(withTitle);
+    return {
+        type: 'collection',
+        slug: augmented.slug,
+        kebab: toKebabCase(augmented.slug),
+        label: augmented.label,
+        auth: augmented.auth,
+        nested: augmented.nested,
+        upload: augmented.upload,
+        fields: augmented.fields,
+        asTitle: augmented.asTitle,
+        asThumbnail: augmented.asThumbnail,
+        versions: augmented.versions,
+        icon: augmented.icon || FileText,
+        live: incomingConfig.live || false,
+        panel: incomingConfig.panel,
+        access: {
+            create: (user) => access.isStaff(user),
+            read: (user) => access.isStaff(user),
+            update: (user) => access.isStaff(user),
+            delete: (user) => access.isStaff(user),
+            ...(incomingConfig.access || {})
+        }
+    };
+};

package/dist/core/collections/config/builder.server.d.ts

@@ -0,0 +1,16 @@
+import type { CollectionWithoutSlug } from './types.js';
+import type { BuiltCollection } from '../../config/types.js';
+export declare const create: <S extends string>(slug: S, incomingConfig: CollectionWithoutSlug<S>) => BuiltCollection;
+export declare const hook: {
+    beforeOperation: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").HookBeforeOperation<S, import("../../operations/hooks/index.server.js").Operation>) => import("../../operations/hooks/index.server.js").HookBeforeOperation<S, import("../../operations/hooks/index.server.js").Operation>;
+    beforeRead: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "read", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "read", "before">;
+    beforeCreate: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "create", "before">;
+    beforeUpsert: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "before">;
+    beforeUpdate: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "update", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "update", "before">;
+    beforeDelete: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "delete", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "delete", "before">;
+    afterRead: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "read", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "read", "after">;
+    afterCreate: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "create", "after">;
+    afterUpsert: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "after">;
+    afterUpdate: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "update", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "update", "after">;
+    afterDelete: <S extends import("../../types/doc.js").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "delete", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "delete", "after">;
+};

package/dist/core/collections/config/builder.server.js

@@ -0,0 +1,44 @@
+import { augmentAuthServer } from './augment-auth.server.js';
+import { augmentHooks } from './augment-hooks.server.js';
+import { augmentMetas } from './augment-metas.js';
+import { augmentNestedServer } from './augment-nested.server.js';
+import { augmentTitle } from './augment-title.js';
+import { augmentUploadServer } from './augment-upload.server.js';
+import { augmentUrl } from './augment-url.js';
+import { augmentVersions } from './augment-versions.js';
+import { Hooks } from '../../operations/hooks/index.server.js';
+import { toKebabCase } from '../../../util/string.js';
+import { FileText } from '@lucide/svelte';
+import { augmentLabel } from './augment-label.js';
+import { augmentThumbnail } from './augment-thumbnail.js';
+export const create = (slug, incomingConfig) => {
+    //
+    const collection = { ...incomingConfig, slug };
+    const initial = { ...collection };
+    const withLabel = augmentLabel(initial);
+    const withUpload = augmentUploadServer(withLabel);
+    const withNested = augmentNestedServer(withUpload);
+    const withVersions = augmentVersions(withNested);
+    const withUrl = augmentUrl(withVersions);
+    const withAuth = augmentAuthServer(withUrl);
+    const withMetas = augmentMetas(withAuth);
+    const withHooks = augmentHooks(withMetas);
+    const withTitle = augmentTitle(withHooks);
+    const augmented = augmentThumbnail(withTitle);
+    return {
+        ...augmented,
+        $url: augmented.$url,
+        slug: augmented.slug,
+        kebab: toKebabCase(augmented.slug),
+        type: 'collection',
+        icon: augmented.icon || FileText,
+        access: {
+            create: (user) => !!user && !!user.isStaff,
+            read: (user) => !!user && !!user.isStaff,
+            update: (user) => !!user && !!user.isStaff,
+            delete: (user) => !!user && !!user.isStaff,
+            ...augmented.access
+        }
+    };
+};
+export const hook = Hooks;

package/dist/core/collections/config/types.d.ts

@@ -0,0 +1,3 @@
+import type { Collection } from '../../config/types.js';
+import type { OmitPreservingDiscrimination } from '../../../util/types.js';
+export type CollectionWithoutSlug<S> = OmitPreservingDiscrimination<Collection<S>, 'slug'>;

package/dist/core/collections/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/collections/local-api.server.d.ts

@@ -0,0 +1,165 @@
+import { type RegisterCollection } from '../../index.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { BuiltCollection } from '../config/types.js';
+import type { CollectionSlug } from '../types/doc.js';
+import { create } from './operations/create.js';
+import { deleteDocs } from './operations/delete.js';
+import { deleteById } from './operations/deleteById.js';
+import { duplicate } from './operations/duplicate.js';
+import { find } from './operations/find.js';
+import { findById } from './operations/findById.js';
+import { updateById } from './operations/updateById.js';
+type Args = {
+    config: BuiltCollection;
+    defaultLocale: string | undefined;
+    event: RequestEvent;
+};
+/**
+ * Facade for interacting with a collection
+ *
+ * Provides methods to create, retrieve, update, and delete documents within a collection.
+ * Handles versioning, drafts, authentication, and localization according to the collection configuration.
+ */
+declare class CollectionAPI<Doc extends RegisterCollection[CollectionSlug]> {
+    #private;
+    defaultLocale: string | undefined;
+    config: BuiltCollection;
+    isSystemOperation: boolean;
+    /**
+     * Initializes the collection facade
+     */
+    constructor({ config, defaultLocale, event }: Args);
+    system(isSytem?: boolean): CollectionAPI<never>;
+    /**
+     * Creates a blank document based on the collection schema
+     * For auth collections, private fields are filtered out
+     *
+     * @returns A blank document with default values
+     *
+     * @example
+     * const emptyDoc = rime.collection('posts').blank();
+     */
+    blank(): Doc;
+    /**
+     * Checks if this collection is an authentication collection
+     *
+     * @returns True if this is an auth collection
+     */
+    get isAuth(): boolean;
+    /**
+     * Creates a new document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').create({
+     *   data: { title: 'Hello World', content: 'My first post' },
+     *   locale: 'en'
+     * });
+     */
+    create(args: APIMethodArgs<typeof create>): Promise<Doc>;
+    /**
+     * Duplicate a document in the collection
+     *
+     * @example
+     * const post = await rime.collection('posts').duplicate({
+     *   id: '1234'
+     * });
+     */
+    duplicate(args: APIMethodArgs<typeof duplicate>): Promise<string>;
+    /**
+     * Finds documents in the collection matching the query
+     *
+     * @example
+     * // Find published posts sorted by creation date
+     * const posts = await rime.collection('posts').find({
+     *   query: { published: true },
+     *   sort: '-createdAt',
+     *   limit: 10
+     * });
+     */
+    find(args: APIMethodArgs<typeof find>): Promise<Doc[]>;
+    /**
+     * Finds a document in the collection by ID
+     *
+     * For collections with versioning:
+     * - If versionId is provided: Retrieves that specific version
+     * - If no versionId and draft=true: Retrieves the latest draft if available
+     * - If no versionId and draft=false: Retrieves the published version
+     *
+     * @example
+     * // Get published version
+     * const post = await rime.collection('posts').findById({ id: '12345' });
+     *
+     * // Get specific version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   versionId: 'v2',
+     *   locale: 'en'
+     * });
+     *
+     * // Get latest draft version
+     * const post = await rime.collection('posts').findById({
+     *   id: '12345',
+     *   draft: true
+     * });
+     */
+    findById(args: APIMethodArgs<typeof findById>): Promise<Doc>;
+    /**
+     * Updates a document in the collection by ID
+     *
+     * For collections with versioning:
+     * - For non-versioned collections: Simply updates the document
+     * - For versioned collections without draft support:
+     *   - If versionId is provided: Updates that specific version
+     *   - If no versionId is provided: Creates a new version based on the latest
+     * - For versioned collections with draft support:
+     *   - If versionId is provided: Updates that specific version
+     *   - If no versionId and draft !== true: Updates the published version
+     *   - If no versionId and draft === true: Creates a new draft from the published version
+     *
+     * @example
+     * // Update published version
+     * const post = await rime.collection('posts').updateById({
+     *   id: '12345',
+     *   data: { title: 'New title' },
+     *   locale: 'en'
+     * });
+     *
+     * // Update specific version
+     * const post = await rime.collection('posts').updateById({
+     *   id: '12345',
+     *   versionId: 'v2',
+     *   data: { title: 'New title' },
+     *   locale: 'en'
+     * });
+     *
+     * // Create or update draft version
+     * const post = await rime.collection('posts').updateById({
+     *   id: '12345',
+     *   data: { title: 'Draft title' },
+     *   draft: true
+     * });
+     */
+    updateById(args: APIMethodArgs<typeof updateById>): Promise<Doc>;
+    /**
+     * Deletes a document in the collection by ID
+     *
+     * @example
+     * const post = await rime.collection('posts').deleteById('12345');
+     */
+    deleteById: ({ id }: APIMethodArgs<typeof deleteById>) => Promise<string>;
+    /**
+     * Deletes multiple documents in the collection
+     *
+     * @example
+     * const posts = await rime.collection('posts').delete({
+     *   query: { published: true },
+     *   limit: 10
+     * });
+     */
+    delete: (args: APIMethodArgs<typeof deleteDocs>) => Promise<string[]>;
+}
+export { CollectionAPI };
+/****************************************************
+/* Types
+/****************************************************/
+type APIMethodArgs<T extends (...args: any) => any> = Omit<Parameters<T>[0], 'rime' | 'event' | 'config' | 'slug'>;