rimecms 0.31.5 → 0.32.1

package/dist/core/operations/hooks/before-upsert/validate-fields.server.js

@@ -1,150 +0,0 @@
-import { PARAMS } from '../../../constant.js';
-import { RimeError, RimeFormError } from '../../../errors/index.js';
-import { logger } from '../../../logger/index.server.js';
-import { deleteValueAtPath, getValueAtPath, setValueAtPath } from '../../../../util/object.js';
-import { Hooks } from '../index.server.js';
-export const validateFields = Hooks.beforeUpsert(async (args) => {
-    const errors = {};
-    const { event, operation } = args;
-    const { rime, user } = event.locals;
-    // Own copy — an access-denied field gets deleted from here too, not just
-    // from `output`. `updateById` turns this map's keys into `incomingPaths`,
-    // which saveRelations/saveBlocks/saveTreeBlocks use to decide which
-    // existing rows are even in scope for this request; leaving a denied
-    // field's path in there made its silently-dropped write look like an
-    // explicit "no relations/blocks here anymore" and delete the existing data.
-    const configMap = { ...args.context.configMap };
-    const locale = args.context.params.locale || args.event.locals.locale;
-    const slug = args.config.slug;
-    const isCollection = rime.config.isCollection(slug);
-    let output = { ...args.data };
-    if (!configMap)
-        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @validateFields');
-    // Get the skip parameter from the url
-    const paramSkip = event.url.searchParams.get(PARAMS.SKIP_VALIDATION) === 'true' || false;
-    // Skip validation/hooks on locale fallback — this data is `omitId(document)`
-    // read back from the just-created document (see create.ts's other-locales
-    // loop), already fully processed once. skipHooks gates validate() as well
-    // as beforeValidate/beforeSave: a non-idempotent hook (e.g. appending a
-    // suffix) would otherwise re-apply itself on every other locale and
-    // corrupt non-localized fields, which share the same underlying storage
-    // across locales.
-    const skipUnique = args.context.isFallbackLocale || paramSkip;
-    const skipHooks = args.context.isFallbackLocale || paramSkip;
-    const skipRequired = args.context.isFallbackLocale || paramSkip;
-    const skipAccess = args.context.isFallbackLocale || args.context.isSystemOperation;
-    for (const [key, config] of Object.entries(configMap)) {
-        let value = getValueAtPath(key, output);
-        /****************************************************/
-        /* Validation
-        /****************************************************/
-        // Unique
-        /** @TODO better unique check like relations, locale,... */
-        if ('unique' in config.get && config.get.unique && isCollection && !skipUnique) {
-            let query;
-            switch (operation) {
-                case 'create':
-                    query = `where[${key}][equals]=${value}`;
-                    break;
-                case 'update':
-                    if (!args.context.originalDoc)
-                        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @validateFields');
-                    query = `where[and][0][${key}][equals]=${value}&where[and][1][id][not_equals]=${args.context.originalDoc.id}&select=id`;
-            }
-            const existing = await rime
-                .collection(slug)
-                .system()
-                .find({ locale, query, select: ['id'] });
-            if (existing.length) {
-                errors[key] = RimeFormError.UNIQUE_FIELD;
-            }
-        }
-        /****************************************************/
-        /* Field hook before validate
-        /****************************************************/
-        if (value !== undefined && value !== null && !skipHooks) {
-            value = await config.use.beforeValidate(value, { config, data: args.data });
-            output = setValueAtPath(key, output, value);
-        }
-        /****************************************************/
-        /* Validate
-        /****************************************************/
-        if (config.get.validate && value !== undefined && value !== null && !skipHooks) {
-            try {
-                const valid = config.use.validate(value, {
-                    data: output,
-                    operation,
-                    id: operation === 'update' ? args.context.originalDoc?.id : undefined,
-                    user: user,
-                    locale,
-                    config: config.get
-                });
-                if (valid !== true) {
-                    errors[key] = valid;
-                }
-            }
-            catch (err) {
-                logger.warn(`Error while validating field ${key}`);
-                console.debug(`[validateFields] field "${key}" threw:`, err);
-                errors[key] = RimeFormError.VALIDATION_ERROR;
-            }
-        }
-        /*
-        /* Field hook before Save
-        */
-        if (value !== undefined && value !== null && !skipHooks) {
-            value = await config.use.beforeSave(value, {
-                config: config.get,
-                event,
-                operation: args.context
-            });
-            output = setValueAtPath(key, output, value);
-        }
-        /****************************************************/
-        /* Access
-        /****************************************************/
-        if (operation === 'update' && !skipAccess) {
-            const authorizedFieldUpdate = config.use.accessUpdate(user, {
-                id: args.context.originalDoc?.id
-            });
-            if (!authorizedFieldUpdate) {
-                output = deleteValueAtPath(output, key);
-                delete configMap[key];
-                value = undefined;
-            }
-        }
-        if (operation === 'create' && !skipAccess) {
-            const authorizedFieldCreate = config.use.accessCreate(user, {
-                id: undefined
-            });
-            if (!authorizedFieldCreate) {
-                output = deleteValueAtPath(output, key);
-                delete configMap[key];
-                value = undefined;
-            }
-        }
-        // Required
-        if (config.get.required && config.use.isEmpty(value)) {
-            if (skipRequired) {
-                // The field's own type-correct default (falling back to '' only
-                // when none is set) — a hardcoded '' here was wrong for every
-                // non-string required field (number, checkbox, date, ...).
-                output = setValueAtPath(key, output, config.use.defaultValue({ event }) ?? '');
-            }
-            else {
-                errors[key] = RimeFormError.REQUIRED_FIELD;
-            }
-        }
-    }
-    if (Object.keys(errors).length) {
-        throw new RimeFormError(errors);
-    }
-    return {
-        ...args,
-        data: output,
-        context: {
-            ...args.context,
-            configMap
-        }
-    };
-});

package/dist/core/operations/hooks/index.server.d.ts

@@ -1,128 +0,0 @@
-import type { VersionOperation } from '../../collections/versions/operations.js';
-import type { BuiltArea, BuiltCollection } from '../../config/types.js';
-import type { Docs, DocType, RawDoc } from '../../types/doc.js';
-import type { OperationQuery } from '../../types/index.js';
-import type { RegisterArea, RegisterCollection } from '../../../index.js';
-import type { PrototypeSlug } from '../../../types.js';
-import type { DeepPartial, Dic } from '../../../util/types.js';
-import type { RequestEvent } from '@sveltejs/kit';
-import type { ConfigMap } from '../configMap/types.js';
-export type Operation = 'read' | 'create' | 'update' | 'delete';
-export type Timing = 'before' | 'after';
-export type DocTypeForSlugs<S extends DocType = PrototypeSlug> = S extends PrototypeSlug ? S extends keyof RegisterCollection ? RegisterCollection[S] : S extends keyof RegisterArea ? RegisterArea[S] : RawDoc : S extends keyof Docs ? Docs[S] : RawDoc;
-export type ConfigForSlug<S extends DocType = PrototypeSlug> = S extends keyof RegisterCollection ? BuiltCollection & {
-    slug: S;
-} : S extends keyof RegisterArea ? BuiltArea & {
-    slug: S;
-} : S extends 'auth' | 'upload' | 'directory' ? BuiltCollection : BuiltArea | BuiltCollection;
-export type HookContext<S extends DocType = PrototypeSlug, O extends Operation = Operation, T extends Timing = Timing> = {
-    event: RequestEvent;
-    context: OperationContext<S>;
-    config: ConfigForSlug<S>;
-    operation: O;
-} & (T extends 'before' ? O extends 'create' ? {
-    data: DeepPartial<DocTypeForSlugs<S>>;
-    doc?: never;
-} : O extends 'read' ? {
-    doc: DocTypeForSlugs<S>;
-    data?: never;
-} : O extends 'update' ? {
-    data: DeepPartial<DocTypeForSlugs<S>>;
-    doc?: never;
-} : O extends 'delete' ? {
-    doc: DocTypeForSlugs<S>;
-    data?: never;
-} : object : T extends 'after' ? O extends 'create' ? {
-    data: DeepPartial<DocTypeForSlugs<S>>;
-    doc: DocTypeForSlugs<S>;
-} : O extends 'read' ? {
-    doc: DocTypeForSlugs<S>;
-    data?: never;
-} : O extends 'update' ? {
-    data: DeepPartial<DocTypeForSlugs<S>>;
-    doc: DocTypeForSlugs<S>;
-} : O extends 'delete' ? {
-    doc: DocTypeForSlugs<S>;
-    data?: never;
-} : object : object);
-export type Hook<S extends DocType = PrototypeSlug, O extends Operation = Operation, T extends Timing = Timing> = (context: HookContext<S, O, T>) => Promise<HookContext<S, O, T>>;
-type HookBeforeOperationArgs<S extends DocType = PrototypeSlug, O extends Operation = Operation> = {
-    event: RequestEvent;
-    context: OperationContext<S>;
-    config: S extends PrototypeSlug ? ConfigForSlug<S> : BuiltCollection | BuiltArea;
-    operation: O;
-};
-export type HookBeforeOperation<S extends DocType = PrototypeSlug, O extends Operation = Operation> = (args: HookBeforeOperationArgs<S, O>) => Promise<HookBeforeOperationArgs<S, O>>;
-/**
- * Helper object for creating hooks with specific operation and timing
- */
-export declare const Hooks: {
-    /**
-     * Creates a before read hook
-     */
-    beforeOperation: <S extends DocType = "raw">(handler: HookBeforeOperation<S, Operation>) => HookBeforeOperation<S, Operation>;
-    /**
-     * Creates a before read hook
-     */
-    beforeRead: <S extends DocType = "raw">(handler: Hook<S, "read", "before">) => Hook<S, "read", "before">;
-    /**
-     * Creates a before create hook
-     */
-    beforeCreate: <S extends DocType = "raw">(handler: Hook<S, "create", "before">) => Hook<S, "create", "before">;
-    /**
-     * Creates a before upsert hook
-     */
-    beforeUpsert: <S extends DocType = "raw">(handler: Hook<S, "create" | "update", "before">) => Hook<S, "create" | "update", "before">;
-    /**
-     * Creates a before update hook
-     */
-    beforeUpdate: <S extends DocType = "raw">(handler: Hook<S, "update", "before">) => Hook<S, "update", "before">;
-    /**
-     * Creates a before delete hook
-     */
-    beforeDelete: <S extends DocType = "raw">(handler: Hook<S, "delete", "before">) => Hook<S, "delete", "before">;
-    /**
-     * Creates an after create hook
-     */
-    afterCreate: <S extends DocType = "raw">(handler: Hook<S, "create", "after">) => Hook<S, "create", "after">;
-    /**
-     * Creates an after create hook
-     */
-    afterUpsert: <S extends DocType = "raw">(handler: Hook<S, "create" | "update", "after">) => Hook<S, "create" | "update", "after">;
-    /**
-     * Creates an after update hook
-     */
-    afterUpdate: <S extends DocType = "raw">(handler: Hook<S, "update", "after">) => Hook<S, "update", "after">;
-    /**
-     * Creates an after delete hook
-     */
-    afterDelete: <S extends DocType = "raw">(handler: Hook<S, "delete", "after">) => Hook<S, "delete", "after">;
-};
-export type OperationContext<S extends DocType = 'raw'> = Dic & {
-    /** Parameters passed to the original operation method */
-    params: {
-        id?: string;
-        versionId?: string;
-        sort?: string;
-        locale?: string;
-        offset?: number;
-        limit?: number;
-        depth?: number;
-        select?: string[];
-        query?: OperationQuery;
-        draft?: boolean;
-    };
-    /** Parameter passed to an update operation when creating locale document fallback */
-    isFallbackLocale?: string | undefined;
-    /** Type of version operation */
-    versionOperation?: VersionOperation;
-    /** The original document if on an update operation */
-    originalDoc?: DocTypeForSlugs<S>;
-    /** An map to get a field config by path on the original doc */
-    originalConfigMap?: ConfigMap;
-    /** An map to get a field config by path on incoming data */
-    configMap?: ConfigMap;
-    /** @TODO explain what it does */
-    isSystemOperation?: boolean;
-};
-export {};

package/dist/core/operations/hooks/index.server.js

@@ -1,45 +0,0 @@
-/**
- * Helper object for creating hooks with specific operation and timing
- */
-export const Hooks = {
-    /**
-     * Creates a before read hook
-     */
-    beforeOperation: (handler) => handler,
-    /**
-     * Creates a before read hook
-     */
-    beforeRead: (handler) => handler,
-    /**
-     * Creates a before create hook
-     */
-    beforeCreate: (handler) => handler,
-    /**
-     * Creates a before upsert hook
-     */
-    beforeUpsert: (handler) => handler,
-    /**
-     * Creates a before update hook
-     */
-    beforeUpdate: (handler) => handler,
-    /**
-     * Creates a before delete hook
-     */
-    beforeDelete: (handler) => handler,
-    /**
-     * Creates an after create hook
-     */
-    afterCreate: (handler) => handler,
-    /**
-     * Creates an after create hook
-     */
-    afterUpsert: (handler) => handler,
-    /**
-     * Creates an after update hook
-     */
-    afterUpdate: (handler) => handler,
-    /**
-     * Creates an after delete hook
-     */
-    afterDelete: (handler) => handler
-};

package/dist/core/operations/relations/diff.server.d.ts

@@ -1,14 +0,0 @@
-import type { BeforeOperationRelation } from '../../../adapter-sqlite/relations.server.js';
-import type { Relation } from '../../../fields/relation/index.js';
-export type RelationDiff = {
-    toAdd: BeforeOperationRelation[];
-    toDelete: Relation[];
-    toUpdate: Relation[];
-};
-type Args = {
-    existingRelations: Relation[];
-    incomingRelations: BeforeOperationRelation[];
-    locale?: string;
-};
-export declare const defineRelationsDiff: ({ existingRelations, incomingRelations, locale }: Args) => RelationDiff;
-export {};

package/dist/core/operations/relations/diff.server.js

@@ -1,47 +0,0 @@
-import { pathToRegex } from '../../fields/util.js';
-const needUpdate = (existing, incoming) => !(existing.position === incoming.position &&
-    existing[`${incoming.relationTo}Id`] === incoming.documentId &&
-    existing.path === incoming.path &&
-    (incoming.locale ? existing.locale === incoming.locale : existing.locale === null));
-export const defineRelationsDiff = ({ existingRelations, incomingRelations, locale }) => {
-    const toAdd = [];
-    const toDelete = [];
-    const toUpdate = [];
-    const processedIds = new Set(); // Keep track of processed IDs
-    // Process incoming relations
-    for (const incoming of incomingRelations) {
-        const existingMatch = existingRelations.find((existing) => (incoming.id && existing.id === incoming.id) ||
-            (!incoming.id &&
-                existing[`${incoming.relationTo}Id`] === incoming.documentId &&
-                existing.path === incoming.path &&
-                (incoming.locale ? existing.locale === incoming.locale : existing.locale === null)));
-        if (existingMatch) {
-            // Only add to toUpdate if we haven't processed this ID yet and if not all props are the same
-            if (!processedIds.has(existingMatch.id) && needUpdate(existingMatch, incoming)) {
-                toUpdate.push({
-                    ...existingMatch,
-                    path: incoming.path,
-                    position: incoming.position
-                });
-                processedIds.add(existingMatch.id);
-            }
-        }
-        else {
-            toAdd.push(incoming);
-        }
-    }
-    // Find relations to delete
-    toDelete.push(...existingRelations.filter((existing) => {
-        // Keep relations from other locales
-        if (existing.locale && existing.locale !== locale) {
-            return false;
-        }
-        // Delete if not found in incoming relations
-        return !incomingRelations.some((incoming) => (incoming.id && existing.id === incoming.id) ||
-            (!incoming.id &&
-                existing[`${incoming.relationTo}Id`] === incoming.documentId &&
-                pathToRegex(existing.path).test(incoming.path) &&
-                (incoming.locale ? existing.locale === incoming.locale : existing.locale === null)));
-    }));
-    return { toAdd, toDelete, toUpdate };
-};

package/dist/core/operations/relations/extract.server.d.ts

@@ -1,11 +0,0 @@
-import type { BeforeOperationRelation } from '../../../adapter-sqlite/relations.server.js';
-import type { Dic } from '../../../util/types.js';
-import type { ConfigMap } from '../configMap/types.js';
-type Args = {
-    ownerId?: string;
-    data: Dic;
-    configMap: ConfigMap;
-    locale: string | undefined;
-};
-export declare const extractRelations: ({ ownerId, data, configMap, locale }: Args) => BeforeOperationRelation[];
-export {};

package/dist/core/operations/relations/extract.server.js

@@ -1,59 +0,0 @@
-import { RelationFieldBuilder } from '../../../fields/relation/index.js';
-import { getValueAtPath } from '../../../util/object.js';
-export const extractRelations = ({ ownerId, data, configMap, locale }) => {
-    const relations = [];
-    for (const [path, config] of Object.entries(configMap)) {
-        if (config instanceof RelationFieldBuilder) {
-            const value = getValueAtPath(path, data);
-            const localized = config.get.localized;
-            const relationRawValue = value;
-            let output = [];
-            const relationFromString = ({ value, position = 0 }) => {
-                const result = {
-                    position,
-                    relationTo: config.get.relationTo,
-                    documentId: value,
-                    ownerId,
-                    path
-                };
-                if (localized) {
-                    result.locale = locale;
-                }
-                return result;
-            };
-            const completeRelation = ({ value, position = 0 }) => {
-                const result = {
-                    id: value.id || undefined,
-                    position,
-                    relationTo: config.get.relationTo,
-                    documentId: value.documentId,
-                    ownerId,
-                    path
-                };
-                if (localized) {
-                    result.locale = locale;
-                }
-                return result;
-            };
-            // If value is array
-            if (Array.isArray(relationRawValue)) {
-                output = relationRawValue.map((value, n) => {
-                    // Array of string build the relation value
-                    if (typeof value === 'string') {
-                        return relationFromString({ value, position: n });
-                    }
-                    else {
-                        // Complete possible missing props
-                        return completeRelation({ value, position: n });
-                    }
-                });
-                // Check if it's a string
-            }
-            else if (typeof relationRawValue === 'string') {
-                output = [relationFromString({ value: relationRawValue, position: 0 })];
-            }
-            relations.push(...output);
-        }
-    }
-    return relations;
-};

package/dist/core/operations/relations/index.server.d.ts

@@ -1,25 +0,0 @@
-import type { Adapter } from '../../../adapter-sqlite/index.server.js';
-import type { BuiltArea, BuiltCollection } from '../../config/types.js';
-import type { GenericBlock } from '../../types/doc.js';
-import type { Dic } from '../../../util/types.js';
-import type { ConfigMap } from '../configMap/types.js';
-import type { TreeBlocksDiff } from '../tree/diff.server.js';
-type Diff<T> = {
-    toAdd: (Omit<T, 'id'> & {
-        id?: string;
-    })[];
-    toDelete: T[];
-    toUpdate: T[];
-};
-export declare const saveRelations: (args: {
-    data: Dic;
-    configMap: ConfigMap;
-    incomingPaths: string[];
-    blocksDiff: Diff<GenericBlock>;
-    treeDiff: TreeBlocksDiff;
-    adapter: Adapter;
-    locale?: string;
-    config: BuiltArea | BuiltCollection;
-    ownerId: string;
-}) => Promise<import("./diff.server.js").RelationDiff>;
-export {};

package/dist/core/operations/relations/index.server.js

@@ -1,68 +0,0 @@
-import { withVersionsSuffix } from '../../naming.js';
-import { defineRelationsDiff } from './diff.server.js';
-import { extractRelations } from './extract.server.js';
-export const saveRelations = async (args) => {
-    const { configMap, incomingPaths, blocksDiff, treeDiff, adapter, locale, config, ownerId, data } = args;
-    const parentTable = config.versions ? withVersionsSuffix(config.slug) : config.slug;
-    /** Delete relations from deletedBlocks */
-    await adapter.relations.deleteFromPaths({
-        parentSlug: parentTable,
-        ownerId,
-        paths: blocksDiff.toDelete.map((block) => `${block.path}.${block.position}`),
-        locale
-    });
-    /** Delete relations from deletedTreeItems */
-    await adapter.relations.deleteFromPaths({
-        parentSlug: parentTable,
-        ownerId,
-        paths: treeDiff.toDelete.map((block) => `${block.path}.${block.position}`),
-        locale
-    });
-    /** Get relations in data */
-    const incomingRelations = extractRelations({
-        ownerId,
-        data,
-        configMap,
-        locale
-    });
-    // get existing relations filtered by path
-    // if not present in incoming paths don't keep it.
-    const existingRelations = await adapter.relations
-        .getAll({
-        parentSlug: parentTable,
-        ownerId,
-        locale: locale
-    })
-        .then((relations) => {
-        // Filter existing relations
-        return relations.filter((relation) => {
-            return incomingPaths.some((path) => relation.path?.startsWith(path));
-        });
-    });
-    /** get difference between them */
-    const relationsDiff = defineRelationsDiff({
-        existingRelations,
-        incomingRelations,
-        locale: locale
-    });
-    if (relationsDiff.toDelete.length) {
-        await adapter.relations.delete({
-            parentSlug: parentTable,
-            relations: relationsDiff.toDelete
-        });
-    }
-    if (relationsDiff.toUpdate.length) {
-        await adapter.relations.update({
-            parentSlug: parentTable,
-            relations: relationsDiff.toUpdate
-        });
-    }
-    if (relationsDiff.toAdd.length) {
-        await adapter.relations.create({
-            parentSlug: parentTable,
-            ownerId,
-            relations: relationsDiff.toAdd
-        });
-    }
-    return relationsDiff;
-};

package/dist/core/operations/shared/fallback-data-from-original.d.ts

@@ -1,9 +0,0 @@
-import type { Dic } from '../../../util/types.js';
-import type { ConfigMap } from '../configMap/types.js';
-export declare const fallbackDataFromOriginal: <T extends Dic>(args: {
-    data: T;
-    original: T;
-    configMap: ConfigMap;
-    ignore: string[];
-    mode?: "required" | "all";
-}) => Promise<T>;

package/dist/core/operations/shared/fallback-data-from-original.js

@@ -1,31 +0,0 @@
-import { logger } from '../../logger/index.server.js';
-import { getValueAtPath, setValueAtPath } from '../../../util/object.js';
-export const fallbackDataFromOriginal = async (args) => {
-    //
-    const mode = args.mode || 'all';
-    const { original, configMap, ignore } = args;
-    let output = { ...args.data };
-    for (const [key, config] of Object.entries(configMap)) {
-        // skip keys in ignore list
-        if (ignore.includes(key))
-            continue;
-        // skip if not required and mode is 'required'
-        const shouldUpdate = (config.get.required && mode === 'required') || mode === 'all';
-        if (!shouldUpdate)
-            continue;
-        let value = getValueAtPath(key, output);
-        let isEmpty;
-        try {
-            isEmpty = config.use.isEmpty(value);
-        }
-        catch {
-            isEmpty = false;
-            logger.warn(`Error while checking if field ${key} is empty`);
-        }
-        if (isEmpty) {
-            value = await getValueAtPath(key, original);
-            output = setValueAtPath(key, output, value);
-        }
-    }
-    return output;
-};

package/dist/core/operations/tree/diff.server.d.ts

@@ -1,20 +0,0 @@
-import type { TreeBlock } from '../../types/doc.js';
-import type { WithRequired } from '../../../util/types.js';
-import type { OperationContext } from '../hooks/index.server.js';
-type TreeBlockWithPath = WithRequired<TreeBlock, 'path'>;
-type TreeBlockForUpdate = Omit<TreeBlock, 'id' | 'path'> & {
-    id?: string;
-    path: string;
-};
-export type TreeBlocksDiff = {
-    toAdd: TreeBlockWithPath[];
-    toDelete: TreeBlockWithPath[];
-    toUpdate: TreeBlockForUpdate[];
-};
-type DefineTreeBlocksDiffArgs = {
-    existingBlocks: TreeBlockWithPath[];
-    incomingBlocks: TreeBlockForUpdate[];
-    context: OperationContext;
-};
-export declare function defineTreeBlocksDiff({ existingBlocks, incomingBlocks, context }: DefineTreeBlocksDiffArgs): TreeBlocksDiff;
-export {};