rimecms 0.31.5 → 0.32.0

package/dist/adapter-sqlite/locales.server.js

@@ -0,0 +1,57 @@
+/**
+ * Which locales a read in `locale` draws on, first to last.
+ *
+ * ```
+ * requested locale → default locale → the other locales, in config order
+ * ```
+ *
+ * A localized value comes from the first of these that has it, so a document written in one
+ * locale reads the same in every locale until it is translated, field by field. Structural
+ * fields — blocks, tree, relations — are rows keyed by locale and take no part in this: a locale
+ * has the blocks that were written in it, or none.
+ *
+ * `localization.fallback: false` cuts the list to the requested locale, and a read is one locale
+ * only; so does a caller asking for the locale's own rows with `fallback: false`, as a copy from
+ * one row to another does. `undefined` when the read names no locale.
+ */
+export const localeOrder = (configCtx, locale, fallback = true) => {
+    if (!locale)
+        return undefined;
+    const localization = configCtx.raw.localization;
+    if (!fallback || !localization || localization.fallback === false)
+        return [locale];
+    const order = [locale, localization.default, ...configCtx.getLocalesCodes()];
+    return order.filter((code, index) => order.indexOf(code) === index);
+};
+/** The columns a locales row carries beside its values. */
+const ROW_KEYS = ['id', 'locale', 'ownerId'];
+/**
+ * Nothing written. `''` counts: a required localized column is `NOT NULL DEFAULT ''`, and that is
+ * what it holds when another field's write creates the locale's row.
+ */
+const unwritten = (value) => value === undefined || value === null || value === '';
+/**
+ * One row's worth of values out of the locales rows a read returned, taking each column from the
+ * first row in `order` that holds a value.
+ *
+ * ```
+ * order  ['fr', 'en']
+ * rows   { locale: 'fr', title: 'Accueil', body: null }
+ *        { locale: 'en', title: 'Home',    body: 'Welcome' }
+ * →      { title: 'Accueil', body: 'Welcome' }
+ * ```
+ */
+export const mergeLocaleRows = (rows, order) => {
+    const byLocale = new Map((rows ?? []).map((row) => [row.locale, row]));
+    const ordered = order.map((code) => byLocale.get(code)).filter((row) => !!row);
+    const merged = {};
+    for (const row of ordered) {
+        for (const [key, value] of Object.entries(row)) {
+            if (ROW_KEYS.includes(key))
+                continue;
+            if (unwritten(merged[key]))
+                merged[key] = value;
+        }
+    }
+    return merged;
+};

package/dist/adapter-sqlite/naming.server.d.ts

@@ -0,0 +1,134 @@
+/**
+ * How a table is named, in one place. Names are built from parts, never concatenated at the call
+ * site.
+ *
+ * Four words, and every table in a generated schema is one of them:
+ *
+ * ```
+ * base      pages                                a prototype's own rows
+ * versions  pages__versions                      the second table its content lives in
+ * child     pages__$relations                    hangs off an owner by `ownerId`
+ *           pages__$blocks_hero                  one per block type
+ *           pages__$tree_facts                   one per tree field
+ * branch    pages__$blocks_hero__$$locales       the localized half of whatever it hangs off
+ * ```
+ *
+ * `owner` is the base or the versions table, resolved before a name is wanted — which is what
+ * moves a config's whole subtree of children onto the second table when it gains versions:
+ *
+ * ```ts
+ * tableName({ owner: baseTableName('pages') })
+ * // 'pages'
+ *
+ * tableName({ owner: baseTableName('$pages__versions'), child: { kind: 'blocks', name: 'hero' } })
+ * // 'pages__versions__$blocks_hero'
+ *
+ * tableName({ owner: baseTableName('pages'), child: { kind: 'rels' }, branch: 'locales' })
+ * // 'pages__$relations__$$locales'
+ * ```
+ *
+ * A slug and a table name are both strings and are not interchangeable — `$a__b` lives in `a__b`,
+ * `camelProbe` in `camel_probe`. `TableName` is branded so the compiler catches the mix-up.
+ */
+declare const TABLE_NAME_BRAND: unique symbol;
+/**
+ * A resolved table name, as opposed to a prototype slug.
+ *
+ * A slug reaching a table-name parameter would look up `undefined` in the generated schema and
+ * fail at the request. The brand makes it a build error instead.
+ */
+export type TableName = string & {
+    readonly [TABLE_NAME_BRAND]: true;
+};
+/**
+ * The table a prototype's own rows live in: `$a__b` -> `a__b`, `camelProbe` -> `camel_probe`.
+ * The only way to turn a slug into a table name.
+ */
+export declare const baseTableName: (slug: string) => TableName;
+/**
+ * The name a declared table is exported under, minus the `$` marking it derived.
+ *
+ * ```
+ * $someTable   ->  exported as `someTable`, lives in `some_table`
+ * ```
+ *
+ * The reverse of a prototype's table, where the slug is authored and the SQL name derived from it.
+ * Here the identifier is fixed — whoever declared the table reaches its rows by that name — and
+ * the SQL name is derived.
+ */
+export declare const declaredTableProperty: (slug: string) => TableName;
+export type ChildKind = 'blocks' | 'tree' | 'rels';
+export type TableParts = {
+    /**
+     * The base or versions table this hangs off, already resolved.
+     *
+     * Everything below is named relative to it, which is what makes a config gaining a versions table move
+     * a whole subtree of children onto it.
+     */
+    owner: TableName;
+    /** A child table. `name` is the block type or the tree field; `rels` has no name. */
+    child?: {
+        kind: ChildKind;
+        name?: string;
+    };
+    /** The localized half of whatever the parts above resolve to. */
+    branch?: 'locales';
+};
+/**
+ * Assembles a Drizzle property name from its parts.
+ *
+ * @example
+ * tableName({ owner: pages })                                   // 'pages'
+ * tableName({ owner: pagesShadow, branch: 'locales' })          // 'pages__shadow__$$locales'
+ * tableName({ owner: pages, child: { kind: 'blocks', name: 'hero' }}) // 'pages__$blocks_hero'
+ * tableName({ owner: pages, child: { kind: 'rels' } })          // 'pages__$relations'
+ */
+export declare const tableName: (parts: TableParts) => TableName;
+/**
+ * The SQL table name for a Drizzle property name.
+ *
+ * Identity: property names are already snake-cased with their markers intact, so the two forms
+ * are the same string. Snake-casing a camelCase property name instead produces an unreadable mix
+ * (`pages_shadowBlocksHero` -> `pages_shadow_blocks_hero`), where nothing says which
+ * underscore means what.
+ */
+export declare const toSqlTableName: (drizzleName: TableName) => TableName;
+/**
+ * Every child table of `owner` of a given kind, read back off the schema.
+ *
+ * Excludes the `locales` branches, which are reached through their own owner rather than listed
+ * alongside it. Replaces the three hand-written filters, one of which was misnamed.
+ */
+export declare const childTableNames: (owner: TableName, kind: ChildKind, tables: Record<string, unknown>) => TableName[];
+/**
+ * The relation key a resolved reference's target is joined under.
+ *
+ * ```
+ * updatedBy  ->  updatedBy__$doc
+ * ```
+ *
+ * `__$` marks it structural, like a child table, so nothing converts it to a document path.
+ */
+export declare const JOIN_SUFFIX = "__$doc";
+export declare const joinName: (column: string) => string;
+/**
+ * Generate the column and property names for a field given its name and its parent path.
+ * Snake case is used for the sqlite column name and Camel case is used for the drizzle column
+ * property name.
+ *
+ * A nested field path uses the same `__` segment separator as a slug, and for the same reason: it
+ * must survive case conversion as a boundary rather than collapse into a word break. Hence
+ * `mapSegments`, shared with slug naming.
+ *
+ * @example
+ * // returns { camel : 'groupTitle', snake: 'group__title' }
+ * getSchemaColumnNames({ name: 'title', parentPath: 'group' })
+ */
+export declare function getSchemaColumnNames(args: {
+    name: string;
+    parentPath?: string;
+}): {
+    camel: string;
+    snake: string;
+};
+export {};

package/dist/adapter-sqlite/naming.server.js

@@ -0,0 +1,98 @@
+import { mapSegments, toCamelCase, toSnakeCase } from '../util/string.js';
+/**
+ * The table a prototype's own rows live in: `$a__b` -> `a__b`, `camelProbe` -> `camel_probe`.
+ * The only way to turn a slug into a table name.
+ */
+export const baseTableName = (slug) => mapSegments(slug.replace(/^\$/, ''), toSnakeCase, '__');
+/**
+ * The name a declared table is exported under, minus the `$` marking it derived.
+ *
+ * ```
+ * $someTable   ->  exported as `someTable`, lives in `some_table`
+ * ```
+ *
+ * The reverse of a prototype's table, where the slug is authored and the SQL name derived from it.
+ * Here the identifier is fixed — whoever declared the table reaches its rows by that name — and
+ * the SQL name is derived.
+ */
+export const declaredTableProperty = (slug) => slug.replace(/^\$/, '');
+/**
+ * `__$` marks a child of the owner it is appended to; `rels` needs no name because a prototype
+ * has exactly one relations junction, discriminated by its `path` column rather than by table.
+ */
+const CHILD_MARKER = {
+    blocks: '__$blocks',
+    tree: '__$tree',
+    rels: '__$relations'
+};
+/** `__$$` marks a branch: the half of a table holding its localized columns. */
+const BRANCH_MARKER = '__$$locales';
+/**
+ * Assembles a Drizzle property name from its parts.
+ *
+ * @example
+ * tableName({ owner: pages })                                   // 'pages'
+ * tableName({ owner: pagesShadow, branch: 'locales' })          // 'pages__shadow__$$locales'
+ * tableName({ owner: pages, child: { kind: 'blocks', name: 'hero' }}) // 'pages__$blocks_hero'
+ * tableName({ owner: pages, child: { kind: 'rels' } })          // 'pages__$relations'
+ */
+export const tableName = (parts) => {
+    let name = parts.owner;
+    if (parts.child) {
+        name += CHILD_MARKER[parts.child.kind];
+        if (parts.child.name)
+            name += `_${toSnakeCase(parts.child.name)}`;
+    }
+    return (parts.branch === 'locales' ? `${name}${BRANCH_MARKER}` : name);
+};
+/**
+ * The SQL table name for a Drizzle property name.
+ *
+ * Identity: property names are already snake-cased with their markers intact, so the two forms
+ * are the same string. Snake-casing a camelCase property name instead produces an unreadable mix
+ * (`pages_shadowBlocksHero` -> `pages_shadow_blocks_hero`), where nothing says which
+ * underscore means what.
+ */
+export const toSqlTableName = (drizzleName) => drizzleName;
+/**
+ * Every child table of `owner` of a given kind, read back off the schema.
+ *
+ * Excludes the `locales` branches, which are reached through their own owner rather than listed
+ * alongside it. Replaces the three hand-written filters, one of which was misnamed.
+ */
+export const childTableNames = (owner, kind, tables) => {
+    const prefix = tableName({ owner, child: { kind } });
+    // Keys of the generated schema: table names by construction.
+    return Object.keys(tables).filter((key) => key.startsWith(prefix) && !key.endsWith(BRANCH_MARKER));
+};
+/**
+ * The relation key a resolved reference's target is joined under.
+ *
+ * ```
+ * updatedBy  ->  updatedBy__$doc
+ * ```
+ *
+ * `__$` marks it structural, like a child table, so nothing converts it to a document path.
+ */
+export const JOIN_SUFFIX = '__$doc';
+export const joinName = (column) => `${column}${JOIN_SUFFIX}`;
+/**
+ * Generate the column and property names for a field given its name and its parent path.
+ * Snake case is used for the sqlite column name and Camel case is used for the drizzle column
+ * property name.
+ *
+ * A nested field path uses the same `__` segment separator as a slug, and for the same reason: it
+ * must survive case conversion as a boundary rather than collapse into a word break. Hence
+ * `mapSegments`, shared with slug naming.
+ *
+ * @example
+ * // returns { camel : 'groupTitle', snake: 'group__title' }
+ * getSchemaColumnNames({ name: 'title', parentPath: 'group' })
+ */
+export function getSchemaColumnNames(args) {
+    const name = args.parentPath ? `${args.parentPath}__${args.name}` : args.name;
+    return {
+        camel: mapSegments(name, toCamelCase, '__'),
+        snake: mapSegments(name, toSnakeCase, '__')
+    };
+}

package/dist/adapter-sqlite/order-by.server.d.ts

@@ -0,0 +1,29 @@
+import type { PrototypeSlug } from '../core/prototype/types.js';
+import type { ConfigContext } from '../core/rime.server.js';
+import { type SQL } from 'drizzle-orm';
+import { type TableName } from './naming.server.js';
+type Args = {
+    slug: PrototypeSlug;
+    locale?: string;
+    by?: string;
+    tables: any;
+    configCtx: ConfigContext;
+    /**
+     * The table this prototype's content lives in, when it is not the base row — resolved by the
+     * caller from the versions table it was registered with.
+     *
+     * The question here is "are this prototype's sortable columns on the base row or somewhere
+     * else", which is about tables — so it is answered with a table name, not a config member.
+     */
+    versions?: TableName;
+    /**
+     * The table the ordering is built against.
+     *
+     * A relational query renames the table it selects from — `from "pages" as "d0"` — so both a
+     * plain column and the correlated subqueries below have to name what the caller was handed,
+     * not the imported object. `update` and `delete` do not alias and pass nothing.
+     */
+    rootTable?: any;
+};
+export declare const buildOrderByParam: ({ slug, locale, tables, configCtx, by, versions, rootTable: aliasedRoot }: Args) => SQL<unknown>[];
+export {};

package/dist/adapter-sqlite/order-by.server.js

@@ -0,0 +1,115 @@
+import { logger } from '../core/logger.server.js';
+import { asc, desc, getTableColumns, sql } from 'drizzle-orm';
+import { pathToDatabaseColumn } from './columns.server.js';
+import { localeOrder } from './locales.server.js';
+import { baseTableName, tableName } from './naming.server.js';
+/**
+ * A localized value as a read shows it: the first locale in the fallback order that holds one,
+ * `''` counting as none. `valueIn` is the subquery for one locale.
+ */
+const resolvedValue = (order, valueIn) => order.length > 1
+    ? sql `COALESCE(${sql.join(order.map((code) => sql `NULLIF(${valueIn(code)}, '')`), sql `, `)})`
+    : valueIn(order[0]);
+export const buildOrderByParam = ({ slug, locale, tables, configCtx, by, versions, rootTable: aliasedRoot }) => {
+    // Presence in the schema, not a config member: a declared versions with no table is not one.
+    const hasShadow = !!versions && versions in tables;
+    const getOrderFunc = (str) => {
+        if (typeof str !== 'string')
+            return asc;
+        return str.charAt(0) === '-' ? desc : asc;
+    };
+    // Get the root table — the caller's alias where there is one.
+    const rootTable = aliasedRoot ?? tables[baseTableName(slug)];
+    by = by ? pathToDatabaseColumn(by) : by;
+    // Default case: no sort parameter provided
+    if (!by) {
+        // Default to sorting by updatedAt in descending order
+        return [desc(rootTable.updatedAt)];
+    }
+    // Handle system fields (createdAt/updatedAt)
+    if (by === 'createdAt' || by === 'updatedAt' || by === '-createdAt' || by === '-updatedAt') {
+        // Determine sort direction (asc/desc) based on presence of '-' prefix
+        const orderFunc = getOrderFunc(by);
+        // Remove the '-' prefix if present to get the actual column name
+        const columnStr = by.replace(/^-/, '');
+        return [orderFunc(rootTable[columnStr])];
+    }
+    const orderFunc = getOrderFunc(by);
+    const columnStr = by.replace(/^-/, '');
+    /**
+     * A column on the prototype's own table, whether or not it also has a versions table.
+     *
+     * Checked for a versioned prototype too, which is what lets `?sort=_position` work on one: the
+     * hierarchy and path columns are `$root()` fields and live on the base row.
+     *
+     * Safe in both branches because the two tables' columns are disjoint by construction — the
+     * schema generator sends `$root()` fields to one and everything else to the other — and the
+     * system fields they share (`createdAt`, `updatedAt`) are answered above this.
+     */
+    const rootTableColumns = Object.keys(getTableColumns(rootTable));
+    if (rootTableColumns.includes(columnStr)) {
+        return [orderFunc(rootTable[columnStr])];
+    }
+    // No versions: every remaining sortable column is a localized one.
+    if (!hasShadow) {
+        // Check if it's a localized field in a non-versioned collection
+        if (locale) {
+            const localeTableName = tableName({
+                owner: baseTableName(slug),
+                branch: 'locales'
+            });
+            if (localeTableName in tables) {
+                const localeTable = tables[localeTableName];
+                const localizedColumns = getTableColumns(localeTable);
+                if (Object.keys(localizedColumns).includes(columnStr)) {
+                    // Interpolated, not `sql.raw`: the outer table may be an alias, so its id has to come
+                    // from the column object rather than from a name read off the schema. Parameterises
+                    // each locale on the way past.
+                    const valueIn = (code) => sql `(SELECT DISTINCT ${localeTable[columnStr]} FROM ${localeTable} WHERE ${localeTable.ownerId} = ${rootTable.id} AND ${localeTable.locale} = ${code})`;
+                    return [orderFunc(resolvedValue(localeOrder(configCtx, locale) ?? [locale], valueIn))];
+                }
+            }
+        }
+    }
+    else {
+        const versionsTableName = versions;
+        const versionsTable = tables[versionsTableName];
+        const versionsTableColumns = Object.keys(getTableColumns(versionsTable));
+        // Check if the column exists in the versions table and is not a system field
+        if (versionsTableColumns.includes(columnStr) &&
+            columnStr !== 'createdAt' &&
+            columnStr !== 'updatedAt') {
+            // The value from the newest content row.
+            return [
+                orderFunc(sql `(SELECT DISTINCT ${versionsTable[columnStr]} FROM ${versionsTable} WHERE ${versionsTable.ownerId} = ${rootTable.id} ORDER BY ${versionsTable.updatedAt} DESC LIMIT 1)`)
+            ];
+        }
+        // Check if it's a localized field on the versions table
+        if (locale) {
+            const versionsLocaleTableName = tableName({
+                owner: versionsTableName,
+                branch: 'locales'
+            });
+            if (versionsLocaleTableName in tables) {
+                const localeTable = tables[versionsLocaleTableName];
+                const localizedColumns = getTableColumns(localeTable);
+                if (Object.keys(localizedColumns).includes(columnStr)) {
+                    // Two hops: the newest content row, then its localized value.
+                    const valueIn = (code) => sql `(SELECT ${localeTable[columnStr]}
+                   FROM ${localeTable}
+                  WHERE ${localeTable.ownerId} IN
+                        (SELECT ${versionsTable.id}
+                           FROM ${versionsTable}
+                          WHERE ${versionsTable.ownerId} = ${rootTable.id}
+                          ORDER BY ${versionsTable.updatedAt} DESC LIMIT 1)
+                    AND ${localeTable.locale} = ${code}
+                  LIMIT 1)`;
+                    return [orderFunc(resolvedValue(localeOrder(configCtx, locale) ?? [locale], valueIn))];
+                }
+            }
+        }
+    }
+    logger.warn(`"${by}" is not a property of ${slug}`);
+    // Fallback to ordering by createdAt on the root table
+    return [desc(rootTable.createdAt)];
+};

package/dist/adapter-sqlite/read.server.d.ts

@@ -0,0 +1,78 @@
+import type { BuiltArea, BuiltCollection } from '../core/config/types.js';
+import type { VersionsTable } from '../core/adapter.js';
+import type { OperationQuery } from '../core/pipeline/types.js';
+import type { RawDoc } from '../core/prototype/types.js';
+import type { ConfigContext } from '../core/rime.server.js';
+import type { Dic } from '../util/types.js';
+/**
+ * Reading a prototype's rows.
+ *
+ * The adapter's vocabulary is in `naming.server.ts`: **base**, **versions** (a second table
+ * holding the content), **child** (blocks, tree, the relations junction) and **branch** (the
+ * localized half). "Collection" and "area" are not adapter words. They were, in the two facades
+ * this replaces, and that was the mistake: a whole parallel implementation existed because the
+ * database layer thought the kinds were different things. Diffed, every difference reduced to
+ * one — who supplies the root row's id.
+ *
+ * `singleton` is the one shape fact this side needs: it decides whether a read wants an id.
+ * Writing is `write.server.ts` beside this. One 649-line file held both, and the two halves share
+ * nothing but their imports.
+ */
+type ReadArgs = {
+    slug: string;
+    /** Where the content lives, when not on the base row — `config._versions`. */
+    versions?: VersionsTable;
+    /** Restrict to one root row. Omitted for a singleton, which has exactly one. */
+    id?: string;
+    select?: string[];
+    locale?: string;
+    /** Whether an untranslated field reads from the other locales. `true` unless said otherwise. */
+    localeFallback?: boolean;
+    /** Which content row, when the caller means a particular one. The newest otherwise. */
+    content?: OperationQuery;
+    config: BuiltCollection | BuiltArea;
+};
+/**
+ * Reads one prototype document, merged with the content row it should show.
+ *
+ * Returns `undefined` when there is nothing to read rather than throwing, and the caller decides
+ * what that means — for most callers a 404.
+ *
+ * It does **not** mean "this prototype has never been written": `undefined` also covers a row
+ * that exists with no content row matching the caller's filter. Bootstrapping on it would
+ * write a second singleton row. `ensurePrototypeExists` asks the root table directly, which is
+ * the only question that actually means "absent".
+ *
+ * The one structural difference between reading a singleton and reading one of many is the
+ * `where` on the root row — supply `id`, or don't.
+ */
+export declare const readPrototype: ({ db, tables, configCtx }: DepsWithConfig, { slug, id, select, locale, localeFallback, content, config, versions }: ReadArgs) => Promise<Dic | undefined>;
+export declare const findManyPrototypes: ({ db, tables, configCtx }: DepsWithConfig, args: FindManyArgs) => Promise<RawDoc[]>;
+/** Removes a document. Its content rows and children follow by cascade. */
+type FindManyArgs = {
+    versions?: VersionsTable;
+    slug: string;
+    select?: string[];
+    query?: OperationQuery;
+    sort?: string;
+    limit?: number;
+    offset?: number;
+    locale?: string;
+    /** See `readPrototype`. */
+    localeFallback?: boolean;
+    /** Per document, which content row — see `readPrototype`. */
+    content?: OperationQuery;
+    config: BuiltCollection | BuiltArea;
+};
+/**
+ * `findMany` alone reaches buildOrderByParam and buildWhereParam, which are typed against the
+ * generated schema rather than against `Dic`. The facade this was moved from declared its tables
+ * as `any` for that reason; keeping that here confines the looseness to the one operation that
+ * needs it instead of widening `Deps` for everything.
+ */
+type DepsWithConfig = {
+    db: any;
+    tables: any;
+    configCtx: ConfigContext;
+};
+export {};