rimecms 0.31.5 → 0.32.1

package/dist/core/pipeline/persist/tree/diff.server.js

@@ -0,0 +1,51 @@
+import { RimeError } from '../../../errors/index.js';
+import { isObjectLiteral } from '../../../../util/object.js';
+// Utility to filter out blocks that haven't id
+const blockHasId = (b) => !!b.id;
+export function defineTreeBlocksDiff({ existingBlocks, incomingBlocks, context }) {
+    //
+    const configMap = context.configMap;
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @defineBlocksDiff');
+    // Consider blocks as new if they have temp ID OR no ID at all
+    const toAdd = incomingBlocks.filter((block) => !block.id || block.id.startsWith('temp-'));
+    const toDelete = existingBlocks.filter((existing) => {
+        return !incomingBlocks.some((newBlock) => {
+            // Only compare blocks that have real IDs
+            if (!newBlock.id || newBlock.id.startsWith('temp-'))
+                return false;
+            return newBlock.id === existing.id;
+        });
+    });
+    const toUpdate = incomingBlocks.filter(blockHasId).filter((newBlock) => {
+        // Skip blocks with temp IDs
+        if (newBlock.id.startsWith('temp-'))
+            return false;
+        // Skip block that doesn't exists in existingBlocks
+        const existing = existingBlocks.find((e) => e.id === newBlock.id);
+        if (!existing)
+            return false;
+        // Compare
+        for (const [key, val] of Object.entries(existing)) {
+            // array of string, ex: select field
+            if (Array.isArray(val) && val.length && typeof val[0] === 'string') {
+                for (const [index, item] of val.entries()) {
+                    if (!newBlock[key] || item !== newBlock[key][index]) {
+                        return true;
+                    }
+                }
+            }
+            else if (isObjectLiteral(val)) {
+                if (newBlock[key] && JSON.stringify(val) !== JSON.stringify(newBlock[key])) {
+                    return true;
+                }
+            }
+            else if (val !== newBlock[key]) {
+                // if the value differs from original than it should update
+                return true;
+            }
+        }
+        return false;
+    });
+    return { toAdd, toDelete, toUpdate };
+}

package/dist/core/pipeline/persist/tree/extract.server.d.ts

@@ -0,0 +1,9 @@
+import type { TreeBlock } from '../../../prototype/types.js';
+import type { Dic, WithRequired } from '../../../../util/types.js';
+import type { ConfigMap } from '../../config-map/types.js';
+type ExtractTreesArgs = {
+    data: Dic;
+    configMap: ConfigMap;
+};
+export declare function extractTreeBlocks({ data, configMap }: ExtractTreesArgs): WithRequired<TreeBlock, "path">[];
+export {};

package/dist/core/pipeline/persist/tree/extract.server.js

@@ -0,0 +1,34 @@
+import { getValueAtPath } from '../../../../util/object.js';
+import cloneDeep from 'clone-deep';
+export function extractTreeBlocks({ data, configMap }) {
+    const blocks = [];
+    function processTreeItem(item, index, rootPath, parentPath) {
+        // Create a copy of the item to avoid modifying the original
+        const processedItem = cloneDeep({ ...item });
+        // Set position if not defined
+        processedItem.position = index;
+        // Set path based on whether it's a root level or nested item
+        processedItem.path = parentPath ? `${parentPath}` : rootPath;
+        // Remove children prop as they will be extracted
+        processedItem._children = [];
+        // Add the processed item to the flat array
+        blocks.push(processedItem);
+        // Process children recursively
+        (item._children || []).forEach((child, childIndex) => {
+            processTreeItem(child, childIndex, rootPath, `${processedItem.path}.${processedItem.position}._children` // Create new parent path based on current item's position
+            );
+        });
+    }
+    Object.entries(configMap).forEach(([path, config]) => {
+        if (config.type === 'tree') {
+            const value = getValueAtPath(path, data);
+            const isEmptyValue = config.use.isEmpty(value);
+            if (value && !isEmptyValue) {
+                value.forEach((item, index) => {
+                    processTreeItem(item, index, path, undefined);
+                });
+            }
+        }
+    });
+    return blocks;
+}

package/dist/core/pipeline/persist/tree/index.server.d.ts

@@ -0,0 +1,14 @@
+import type { Adapter } from '../../../adapter.js';
+import type { PrototypeSlug } from '../../../prototype/types.js';
+import type { Dic } from '../../../../util/types.js';
+import type { OperationContext } from '../../types.js';
+export declare const saveTreeBlocks: (args: {
+    context: OperationContext;
+    ownerId: string;
+    data: Dic;
+    incomingPaths: string[];
+    adapter: Adapter;
+    /** Whose children these are — the versions's slug when the prototype has one. Resolved by
+     *  `persistRelational` from what the prototype was registered with. */
+    ownerSlug: PrototypeSlug;
+}) => Promise<import("./diff.server.js").TreeBlocksDiff>;

package/dist/core/pipeline/persist/tree/index.server.js

@@ -0,0 +1,50 @@
+import { RimeError } from '../../../errors/index.js';
+import { defineTreeBlocksDiff } from './diff.server.js';
+import { extractTreeBlocks } from './extract.server.js';
+export const saveTreeBlocks = async (args) => {
+    const { context, ownerId, data, incomingPaths, adapter, ownerSlug } = args;
+    const { locale } = context.params;
+    const { originalDoc: original, configMap, originalConfigMap } = context;
+    if (!configMap || !ownerId)
+        throw new RimeError(RimeError.OPERATION_ERROR, '@saveBlocks');
+    // Get incomings
+    const incomingTreeBlocks = extractTreeBlocks({
+        data,
+        configMap
+    });
+    // Get existings
+    let existingTreeBlocks = [];
+    if (original) {
+        if (!originalConfigMap)
+            throw new RimeError(RimeError.OPERATION_ERROR, 'missing original');
+        const blocks = extractTreeBlocks({
+            data: original,
+            configMap: originalConfigMap
+        });
+        existingTreeBlocks = blocks.filter((block) => {
+            // filter path that are not present in incoming data
+            // in order to not delete unmodified blocks fields
+            return incomingPaths.some((path) => block.path?.startsWith(path));
+        });
+    }
+    const treeDiff = defineTreeBlocksDiff({
+        existingBlocks: existingTreeBlocks,
+        incomingBlocks: incomingTreeBlocks,
+        context
+    });
+    if (treeDiff.toDelete.length) {
+        await Promise.all(treeDiff.toDelete.map((block) => adapter.tree.delete({ parentSlug: ownerSlug, block })));
+    }
+    if (treeDiff.toAdd.length) {
+        await Promise.all(treeDiff.toAdd.map((block) => adapter.tree.create({
+            parentSlug: ownerSlug,
+            ownerId,
+            block,
+            locale: locale
+        })));
+    }
+    if (treeDiff.toUpdate.length) {
+        await Promise.all(treeDiff.toUpdate.map((block) => adapter.tree.update({ parentSlug: ownerSlug, block, locale: locale })));
+    }
+    return treeDiff;
+};

package/dist/core/pipeline/query.d.ts

@@ -0,0 +1,14 @@
+import type { OperationQuery, ParsedOperationQuery } from './types.js';
+/**
+ * Parses and validates an incoming query into `{ where }`.
+ *
+ * Lived in the sqlite adapter, and was core's only runtime import from it — REST's list and
+ * delete handlers called it to normalize a query string before passing it to an operation.
+ * Nothing about it is SQL: it is qs parsing and a shape check over `OperationQuery`, which is
+ * declared next door. An adapter is free to call it, but it is not the adapter's to own.
+ *
+ * @example
+ * // returns
+ * { where: queryObject }
+ */
+export declare function normalizeQuery(incomingQuery: OperationQuery): ParsedOperationQuery;

package/dist/core/pipeline/query.js

@@ -0,0 +1,36 @@
+import { RimeError } from '../errors/index.js';
+import { isObjectLiteral } from '../../util/object.js';
+import qs from 'qs';
+/**
+ * Parses and validates an incoming query into `{ where }`.
+ *
+ * Lived in the sqlite adapter, and was core's only runtime import from it — REST's list and
+ * delete handlers called it to normalize a query string before passing it to an operation.
+ * Nothing about it is SQL: it is qs parsing and a shape check over `OperationQuery`, which is
+ * declared next door. An adapter is free to call it, but it is not the adapter's to own.
+ *
+ * @example
+ * // returns
+ * { where: queryObject }
+ */
+export function normalizeQuery(incomingQuery) {
+    let query;
+    if (typeof incomingQuery === 'string') {
+        try {
+            query = qs.parse(incomingQuery);
+        }
+        catch (err) {
+            throw new RimeError(RimeError.INVALID_DATA, 'Unable to parse given string query ' + err.message);
+        }
+    }
+    else {
+        if (!isObjectLiteral(incomingQuery)) {
+            throw new RimeError(RimeError.INVALID_DATA, 'Query is not an object');
+        }
+        query = incomingQuery;
+    }
+    if (!query.where) {
+        throw new RimeError(RimeError.INVALID_DATA, 'Query must have a root where property');
+    }
+    return query;
+}

package/dist/core/pipeline/run.server.d.ts

@@ -0,0 +1,146 @@
+import type { Adapter } from '../adapter.js';
+import type { BuiltArea, BuiltCollection } from '../config/types.js';
+import type { WritePlan } from '../adapter.js';
+import type { DocType, GenericDoc, RawDoc } from '../prototype/types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { Operation, OperationContext } from './types.js';
+/**
+ * The steps every document operation shares, written once.
+ *
+ * Collections and areas differ in how a document is addressed (an id vs. a singleton) and in
+ * which adapter method writes it — not in the shape of the pipeline around that write. These
+ * helpers hold that shape; the per-prototype operations in this folder supply the two or three
+ * pieces that genuinely differ, as callbacks.
+ *
+ * Hook *ordering* is not decided here — see pipeline.server.ts.
+ */
+type AnyConfig = BuiltCollection | BuiltArea;
+/**
+ * A `WritePlan` that has been through the update path, where a named content row is named.
+ *
+ * The shared type leaves `content.id` optional for inserts; `runUpdate` checks it once and hands
+ * this down, so a `write` callback can pass the plan straight to `adapter.update`.
+ */
+export type UpdateWritePlan = WritePlan & {
+    content?: {
+        id: string;
+        data: Dic;
+    };
+};
+/**
+ * Runs the beforeOperation chain. These hooks see no document and no data — only the context,
+ * which they may replace (authorize, for instance, reads it and throws).
+ */
+export declare const runBeforeOperation: <S extends DocType>(args: {
+    config: AnyConfig;
+    event: RequestEvent;
+    operation: Operation;
+    context: OperationContext<S>;
+}) => Promise<OperationContext<S>>;
+/**
+ * Runs a data-carrying chain (beforeCreate / beforeUpdate).
+ *
+ * All three of data, context and config travel through: a hook may rewrite the incoming data,
+ * stash something on the context, or hand back an amended config — auth's augmentFieldsPassword
+ * appends the password field this way, so the validation step below it sees it.
+ *
+ * Both timings chain all three, create included — a hook that amends the config on create has to
+ * have that config reach the validation below it, or the policy it adds is never enforced.
+ */
+export declare const runDataHooks: <S extends DocType, D, C extends AnyConfig>(args: {
+    hooks: unknown;
+    data: D;
+    config: C;
+    event: RequestEvent;
+    operation: Operation;
+    context: OperationContext<S>;
+}) => Promise<{
+    data: D;
+    config: C;
+    context: OperationContext<S>;
+}>;
+/**
+ * Runs a document-carrying chain (beforeRead / afterCreate / afterUpdate / beforeDelete /
+ * afterDelete). `data` is passed through untouched for the after-upsert timings, which receive
+ * both.
+ */
+export declare const runDocHooks: <S extends DocType, T>(args: {
+    hooks: unknown;
+    doc: T;
+    data?: unknown;
+    config: AnyConfig;
+    event: RequestEvent;
+    operation: Operation;
+    context: OperationContext<S>;
+}) => Promise<{
+    doc: T;
+    context: OperationContext<S>;
+}>;
+/**
+ * Asserts the context carries everything the write path needs by the time the before-hooks are
+ * done. Each name is a hook that should have populated it, so a missing one points at the
+ * pipeline entry that did not run.
+ */
+export declare const assertUpsertContext: (context: OperationContext<any>, where: string, required: readonly ("configMap" | "originalConfigMap" | "originalDoc" | "contentOwnerId")[]) => void;
+/**
+ * Writes a document's blocks, tree blocks and relations. Always these three, always in this
+ * order — relations last, because it needs both diffs to resolve a relation that points at a
+ * block or tree node created in the same pass.
+ */
+export declare const persistRelational: (args: {
+    context: OperationContext<any>;
+    ownerId: string;
+    data: Dic;
+    incomingPaths: string[];
+    adapter: Adapter;
+    config: AnyConfig;
+    locale?: string | undefined;
+}) => Promise<void>;
+/**
+ * The read tail shared by findById and an area's find: turn a raw adapter row into a document,
+ * then run the beforeRead chain over it.
+ */
+export declare const readDocument: <S extends DocType, T extends GenericDoc>(args: {
+    raw: RawDoc;
+    config: AnyConfig;
+    event: RequestEvent;
+    context: OperationContext<S>;
+    locale?: string | undefined;
+    localeFallback?: boolean;
+    depth?: number;
+    select?: string[];
+}) => Promise<{
+    doc: T;
+    context: OperationContext<S>;
+}>;
+/**
+ * The update pipeline, prototype-parameterized.
+ *
+ * Collections and areas run exactly these eight steps in exactly this order; they differ only
+ * in `write` (which adapter method persists the root row) and `reread` (how the saved document
+ * is fetched back). Everything between — the hook chains, the context assertions, the
+ * relational persistence — is identical, so it is written once.
+ */
+export declare const runUpdate: <S extends DocType, T extends GenericDoc, C extends AnyConfig = AnyConfig>(args: {
+    data: Dic;
+    config: C;
+    event: RequestEvent;
+    context: OperationContext<S>;
+    where: string;
+    /** Passed explicitly rather than read off the context, matching what both callers did. */
+    locale?: string | undefined;
+    /** Persists the write plan. Returns whatever `reread` needs to find the document again. */
+    write: (ctx: {
+        plan: UpdateWritePlan;
+        config: C;
+        context: OperationContext<S>;
+    }) => Promise<any>;
+    /** Fetches the saved document back, for the afterUpdate hooks and the caller. */
+    reread: (ctx: {
+        written: any;
+        config: C;
+        context: OperationContext<S>;
+    }) => Promise<T>;
+}) => Promise<T>;
+export {};

package/dist/core/pipeline/run.server.js

@@ -0,0 +1,256 @@
+import { RimeError } from '../errors/index.js';
+import { versionsWritePlan } from '../prototype/shared/versions/write-plan.js';
+import { buildDocument } from './build-document.server.js';
+import { saveBlocks } from './persist/blocks/index.server.js';
+import { saveRelations } from './persist/relations/index.server.js';
+import { saveTreeBlocks } from './persist/tree/index.server.js';
+/**
+ * Runs the beforeOperation chain. These hooks see no document and no data — only the context,
+ * which they may replace (authorize, for instance, reads it and throws).
+ */
+export const runBeforeOperation = async (args) => {
+    let context = args.context;
+    for (const hook of args.config.$hooks?.beforeOperation || []) {
+        const result = await hook({
+            config: args.config,
+            operation: args.operation,
+            event: args.event,
+            context
+        });
+        context = result.context;
+    }
+    return context;
+};
+/**
+ * Runs a data-carrying chain (beforeCreate / beforeUpdate).
+ *
+ * All three of data, context and config travel through: a hook may rewrite the incoming data,
+ * stash something on the context, or hand back an amended config — auth's augmentFieldsPassword
+ * appends the password field this way, so the validation step below it sees it.
+ *
+ * Both timings chain all three, create included — a hook that amends the config on create has to
+ * have that config reach the validation below it, or the policy it adds is never enforced.
+ */
+export const runDataHooks = async (args) => {
+    let { data, config, context } = args;
+    for (const hook of args.hooks || []) {
+        const result = await hook({
+            data,
+            config,
+            operation: args.operation,
+            event: args.event,
+            context
+        });
+        context = result.context;
+        data = result.data;
+        config = result.config;
+    }
+    return { data, config, context };
+};
+/**
+ * Runs a document-carrying chain (beforeRead / afterCreate / afterUpdate / beforeDelete /
+ * afterDelete). `data` is passed through untouched for the after-upsert timings, which receive
+ * both.
+ */
+export const runDocHooks = async (args) => {
+    let { doc, context } = args;
+    for (const hook of args.hooks || []) {
+        const result = await hook({
+            doc,
+            ...(args.data !== undefined ? { data: args.data } : {}),
+            config: args.config,
+            operation: args.operation,
+            event: args.event,
+            context
+        });
+        context = result.context;
+        doc = result.doc;
+    }
+    return { doc, context };
+};
+/**
+ * Asserts the context carries everything the write path needs by the time the before-hooks are
+ * done. Each name is a hook that should have populated it, so a missing one points at the
+ * pipeline entry that did not run.
+ */
+export const assertUpsertContext = (context, where, required) => {
+    for (const name of required) {
+        const present = context[name];
+        if (!present) {
+            throw new RimeError(RimeError.OPERATION_ERROR, `missing ${name} @${where}`);
+        }
+    }
+};
+/**
+ * Writes a document's blocks, tree blocks and relations. Always these three, always in this
+ * order — relations last, because it needs both diffs to resolve a relation that points at a
+ * block or tree node created in the same pass.
+ */
+export const persistRelational = async (args) => {
+    const { context, ownerId, data, incomingPaths, adapter, config, locale } = args;
+    /**
+     * Whose children these are, in slug space.
+     *
+     * Read off the config, which `augmentVersions` stamped. It was a round trip —
+     * `adapter.prototype(config.slug).versions?.slug` — asking the database layer for something the
+     * config already carries, and before that a `contentOwnerSlug(config)` helper in versions'
+     * own folder that three pipeline files imported to name a table.
+     *
+     * `ownerId` is the row; this is the table it is in.
+     *
+     * The cast is the one `findManyPrototypes` takes, and sound for the same reason:
+     * `VersionsTable.slug` is a plain `string` because the feature names a slug and only the
+     * registry knows which exist — but a versions table *is* a registered prototype, since the
+     * feature that declares one also derives its config.
+     */
+    const ownerSlug = (config._versions?.slug ?? config.slug);
+    const blocksDiff = await saveBlocks({
+        context,
+        ownerId,
+        ownerSlug,
+        data,
+        incomingPaths,
+        adapter
+    });
+    const treeDiff = await saveTreeBlocks({
+        context,
+        ownerId,
+        ownerSlug,
+        data,
+        incomingPaths,
+        adapter
+    });
+    await saveRelations({
+        ownerId,
+        ownerSlug,
+        configMap: context.configMap,
+        data,
+        incomingPaths,
+        adapter,
+        locale,
+        blocksDiff,
+        treeDiff
+    });
+};
+/**
+ * The read tail shared by findById and an area's find: turn a raw adapter row into a document,
+ * then run the beforeRead chain over it.
+ */
+export const readDocument = async (args) => {
+    const { raw, config, event, locale, localeFallback, depth, select } = args;
+    const hasSelect = !!select && Array.isArray(select) && !!select.length;
+    const rows = await event.locals.rime.adapter.transform.rows({
+        doc: raw,
+        slug: config.slug,
+        locale,
+        localeFallback
+    });
+    const document = await buildDocument(rows, {
+        config,
+        event,
+        locale,
+        depth,
+        withBlank: !hasSelect,
+        /**
+         * The panel edits blocks and tree nodes in place, so it needs each child row's own
+         * bookkeeping — `position`, `path`, `ownerId`, `locale` — kept on it.
+         *
+         * The adapter used to work this out for itself, by testing `event.params.panel`. Core naming
+         * the panel here is the last of that coupling (core letting go of `src/lib/panel/`), and it
+         * is one line rather than four `if`s in the database layer.
+         */
+        withRowMeta: event.params.panel !== undefined
+    });
+    return runDocHooks({
+        hooks: config.$hooks?.beforeRead,
+        doc: document,
+        config,
+        event,
+        operation: 'read',
+        context: args.context
+    });
+};
+/**
+ * The update pipeline, prototype-parameterized.
+ *
+ * Collections and areas run exactly these eight steps in exactly this order; they differ only
+ * in `write` (which adapter method persists the root row) and `reread` (how the saved document
+ * is fetched back). Everything between — the hook chains, the context assertions, the
+ * relational persistence — is identical, so it is written once.
+ */
+export const runUpdate = async (args) => {
+    const { event, where } = args;
+    // 1. beforeOperation
+    let context = await runBeforeOperation({
+        config: args.config,
+        event,
+        operation: 'update',
+        context: args.context
+    });
+    // 2. beforeUpdate — may rewrite data, context and config
+    const beforeUpdate = await runDataHooks({
+        hooks: args.config.$hooks?.beforeUpdate,
+        data: args.data,
+        config: args.config,
+        event,
+        operation: 'update',
+        context
+    });
+    const { data } = beforeUpdate;
+    const config = beforeUpdate.config;
+    context = beforeUpdate.context;
+    // 3. the before-hooks must have populated all of these
+    assertUpsertContext(context, where, [
+        'configMap',
+        'originalConfigMap',
+        'originalDoc',
+        'contentOwnerId'
+    ]);
+    const incomingPaths = Object.keys(context.configMap);
+    /**
+     * 3.5. which rows this write touches, and with what.
+     *
+     * Here rather than in a hook, and that is the point of it: it has to run after *every* data
+     * hook, and a hook cannot be guaranteed last — a consumer's `beforeUpdate` hook requires
+     * `validated` and provides nothing, so no mark exists for a plan step to wait on. A consumer
+     * hook that rewrote `data` would have been silently split around.
+     *
+     * The default is the whole story for a config with one row: everything goes on it. `versions`
+     * is what refines it (core/prototype/shared/versions/write-plan.ts), and it is why `versionOperation` no longer
+     * travels to the adapter — the enum was only ever a way of saying which rows to write.
+     */
+    const plan = versionsWritePlan({ data }, { config, context, operation: 'update' });
+    // `WritePlan.content.id` is optional because an *insert* has no row to name. An update does, so
+    // the invariant is asserted here, once, rather than cast away at each of the two write sites.
+    if (plan.content && !plan.content.id) {
+        throw new RimeError(RimeError.OPERATION_ERROR, `the update plan for ${config.slug} names a content row with no id`);
+    }
+    const updatePlan = plan;
+    // 4. write the rows the plan names
+    const written = await args.write({ plan: updatePlan, config, context });
+    // 5. blocks, tree, relations — against the row the content lives on
+    await persistRelational({
+        context,
+        ownerId: context.contentOwnerId,
+        data,
+        incomingPaths,
+        adapter: event.locals.rime.adapter,
+        config,
+        locale: args.locale
+    });
+    // 6. read the saved document back
+    const document = await args.reread({ written, config, context });
+    // 7. afterUpdate
+    const after = await runDocHooks({
+        hooks: config.$hooks?.afterUpdate,
+        doc: document,
+        data,
+        config,
+        event,
+        operation: 'update',
+        context
+    });
+    // 8. Return what afterUpdate handed back, matching afterCreate — an afterUpdate hook that
+    // amends the document has to have that document reach the caller.
+    return after.doc;
+};