rimecms 0.31.4 → 0.32.0

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

@@ -0,0 +1,188 @@
+import { normalizeQuery } from '../core/pipeline/query.js';
+import { and, eq } from 'drizzle-orm';
+import { RimeError } from '../core/errors/index.js';
+import { baseTableName } from './naming.server.js';
+import { buildOrderByParam } from './order-by.server.js';
+import * as adapterUtil from './columns.server.js';
+import { buildWhereParam } from './where.server.js';
+import { localeOrder } from './locales.server.js';
+import { buildWithParam, resolvedReferenceJoins } from './select.server.js';
+/**
+ * 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 const readPrototype = async ({ db, tables, configCtx }, { slug, id, select, locale, localeFallback, content, config, versions }) => {
+    const table = baseTableName(slug);
+    const rootTable = tables[table];
+    const fallback = localeOrder(configCtx, locale, localeFallback);
+    // Cast because with a single registered area the slug type collapses to one literal and
+    // Drizzle infers an over-precise per-table shape instead of the general one.
+    const queryTable = db.query[table];
+    const byId = id ? { where: { RAW: (t) => eq(t.id, id) } } : {};
+    // No versions: the content is on the base row and there is nothing to merge.
+    if (!versions) {
+        return queryTable.findFirst({
+            columns: adapterUtil.columnsParams({ table: rootTable, select }),
+            ...byId,
+            with: buildWithParam({ table, select, locale, fallback, tables, config }) || undefined
+        });
+    }
+    // See findManyPrototypes for why the versions table's slug is castable.
+    const versionsSlug = versions.slug;
+    const contentTable = baseTableName(versionsSlug);
+    const doc = await queryTable.findFirst({
+        columns: adapterUtil.columnsParams({ table: rootTable, select }),
+        ...byId,
+        with: {
+            // The base row's own resolved references; the content row's come with `buildWithParam`.
+            ...resolvedReferenceJoins({ table, tables, config, select }),
+            [contentTable]: {
+                columns: adapterUtil.columnsParams({ table: tables[contentTable], select }),
+                with: buildWithParam({ table: contentTable, select, locale, fallback, tables, config }),
+                // The row the caller's filter names, else the newest — one query either way, and the
+                // adapter chooses nothing. Which content row a request means is decided above this module
+                // and arrives as an ordinary filter (`FeatureDefinition.readQuery`).
+                //
+                // The `orderBy`/`limit` are not the third branch coming back: they are what "the content
+                // of this document" means with nothing else said, the same statement as `updatedAt` being
+                // the default sort. A filter narrows within that, it does not replace it.
+                ...(content
+                    ? {
+                        where: {
+                            RAW: (t) => buildWhereParam({
+                                query: normalizeQuery(content),
+                                slug: versionsSlug,
+                                base: slug,
+                                locale,
+                                db,
+                                configCtx,
+                                tables,
+                                rootTable: t
+                            })
+                        }
+                    }
+                    : {}),
+                orderBy: { updatedAt: 'desc' },
+                limit: 1
+            }
+        }
+    });
+    // A base row with no content row is as good as absent — there is nothing to show.
+    if (!doc || !doc[contentTable] || doc[contentTable].length === 0)
+        return undefined;
+    return adapterUtil.mergeContentRow(doc, contentTable, config, select);
+};
+export const findManyPrototypes = async ({ db, tables, configCtx }, args) => {
+    const { select, query: incomingQuery, sort, limit, offset, locale, localeFallback, content, config, versions } = args;
+    // buildOrderByParam and buildWhereParam resolve fields against the config, so they take a
+    // prototype slug. Registration guarantees this one is registered, hence is one.
+    const slug = args.slug;
+    const table = baseTableName(slug);
+    const query = incomingQuery ? normalizeQuery(incomingQuery) : undefined;
+    const fallback = localeOrder(configCtx, locale, localeFallback);
+    // No versions: everything is on the base table, so this is one plain query.
+    if (!versions) {
+        const params = {
+            with: buildWithParam({ table, select, tables, config, locale, fallback }) || undefined,
+            orderBy: (t) => buildOrderByParam({ slug, locale, tables, configCtx, by: sort, rootTable: t }),
+            // sqlite requires a limit when an offset is present.
+            limit: limit || (typeof offset === 'number' ? 1000000 : undefined),
+            offset: offset || undefined
+        };
+        if (query) {
+            params.where = {
+                RAW: (t) => buildWhereParam({ query, slug, locale, db, configCtx, tables, rootTable: t })
+            };
+        }
+        Object.keys(params).forEach((key) => params[key] === undefined && delete params[key]);
+        return await db.query[table].findMany({
+            columns: adapterUtil.columnsParams({ table: tables[table], select }),
+            ...params
+        });
+    }
+    // Two different things that stopped being the same string when the naming convention changed:
+    // buildWithParam reads the schema, so it takes a table name; buildWhereParam resolves fields
+    // against the config, so it takes a slug.
+    // `VersionsTable.slug` is a plain string on purpose — a feature names a slug, and only the
+    // registry knows which slugs exist. The cast is the same one `slug` above takes, and sound for
+    // the same reason: a versions table is a registered prototype in its own right (the feature that
+    // declares one also derives its config), so `buildWhereParam` can resolve fields against it.
+    const versionsSlug = versions.slug;
+    const contentTable = baseTableName(versionsSlug);
+    const withParam = buildWithParam({ table: contentTable, select, tables, config, locale, fallback }) || undefined;
+    // The caller's own filter, and the one saying which content row each document shows. Both
+    // resolve against the versions table, so they are two wheres to `and` rather than two query objects to
+    // splice — which is what this was, a condition spliced into somebody else's `where` by hand
+    // behind a config read.
+    const contentWhere = (rootTable) => {
+        const wheres = [query, content && normalizeQuery(content)]
+            .filter((one) => !!one)
+            .map((one) => buildWhereParam({
+            query: one,
+            slug: versionsSlug,
+            base: slug,
+            locale,
+            db,
+            configCtx,
+            tables,
+            rootTable
+        }))
+            // Only `undefined` drops out. `buildWhereParam` answers `false` for a degenerate query (an
+            // empty `and`/`or`), and that was passed straight to drizzle before; it still is.
+            .filter((one) => one !== undefined);
+        return wheres.length > 1 ? and(...wheres) : wheres[0];
+    };
+    const params = {
+        limit: limit || (typeof offset === 'number' ? 1000000 : undefined),
+        offset: offset,
+        // The sortable columns are on the versions table, so the sort builder is handed it by name.
+        orderBy: (t) => buildOrderByParam({
+            slug,
+            locale,
+            tables,
+            configCtx,
+            by: sort,
+            versions: contentTable,
+            rootTable: t
+        })
+    };
+    Object.keys(params).forEach((key) => params[key] === undefined && delete params[key]);
+    const rawDocs = await db.query[table].findMany({
+        ...params,
+        columns: adapterUtil.columnsParams({ table: tables[table], select }),
+        with: {
+            ...resolvedReferenceJoins({ table, tables, config, select }),
+            [contentTable]: {
+                with: withParam,
+                where: { RAW: contentWhere },
+                orderBy: { updatedAt: 'desc' },
+                limit: 1,
+                columns: adapterUtil.columnsParams({ table: tables[contentTable], select })
+            }
+        }
+    });
+    return rawDocs
+        .map((doc) => {
+        try {
+            return adapterUtil.mergeContentRow(doc, contentTable, config, select);
+        }
+        catch (err) {
+            // A query forwarded to the content table can match nothing for a given document; that
+            // document simply drops out of the result rather than failing the whole read.
+            if (err instanceof RimeError && err.code === RimeError.NOT_FOUND)
+                return false;
+            throw err;
+        }
+    })
+        .filter(Boolean);
+};

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

@@ -0,0 +1,45 @@
+import type { AreaHandle, BaseHandle, CollectionHandle } from '../core/adapter.js';
+import type { BuiltArea, BuiltCollection } from '../core/config/types.js';
+import type { ConfigContext } from '../core/rime.server.js';
+import type { Dic } from '../util/types.js';
+/**
+ * Which prototypes exist, and which handle each one got.
+ *
+ * Prototypes register at boot. That is the whole reason this file exists: the adapter is handed
+ * the prototypes it will serve *once*, rather than working one out from a slug on every request.
+ * It also means a prototype whose tables are missing fails at boot, loudly, in a place that names
+ * it — instead of on whichever request first happened to touch it.
+ *
+ * `config.type` decides which handle a slug gets:
+ *
+ * ```ts
+ * config.type === 'area' ? createAreaHandle(args) : createCollectionHandle(args)
+ * ```
+ */
+export declare const createPrototypeRegistry: (deps: {
+    db: any;
+    tables: Dic;
+    configCtx: ConfigContext;
+}) => {
+    registerPrototype: (config: BuiltArea | BuiltCollection) => void;
+    /**
+     * The two typed lookups.
+     *
+     * The cast is the erasure registration already makes, and sound for the same reason: a slug is
+     * registered under exactly one kind, and `config.type` is what picked the handle above. A
+     * caller holding a `BuiltCollection` asks for a collection; one holding a `BuiltArea` asks for
+     * an area.
+     */
+    collection: (slug: string) => CollectionHandle;
+    area: (slug: string) => AreaHandle;
+    /**
+     * Where this prototype's content lives — its versions table where it has one, itself
+     * otherwise.
+     *
+     * Follows the `versions` each handle was registered with rather than rebuilding the slug from
+     * the naming convention, so the suffix stays the versions feature's to spell. A versioned
+     * prototype whose versions table never registered reaches `lookup` and throws, instead of
+     * falling back to the base table and writing content columns to a table that has none.
+     */
+    contentOwner: (slug: string) => BaseHandle;
+};

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

@@ -0,0 +1,63 @@
+import { RimeError } from '../core/errors/index.js';
+import { createAreaHandle } from './area.server.js';
+import { createCollectionHandle } from './collection.server.js';
+import { baseTableName } from './naming.server.js';
+/**
+ * Which prototypes exist, and which handle each one got.
+ *
+ * Prototypes register at boot. That is the whole reason this file exists: the adapter is handed
+ * the prototypes it will serve *once*, rather than working one out from a slug on every request.
+ * It also means a prototype whose tables are missing fails at boot, loudly, in a place that names
+ * it — instead of on whichever request first happened to touch it.
+ *
+ * `config.type` decides which handle a slug gets:
+ *
+ * ```ts
+ * config.type === 'area' ? createAreaHandle(args) : createCollectionHandle(args)
+ * ```
+ */
+export const createPrototypeRegistry = (deps) => {
+    const { db, tables, configCtx } = deps;
+    const handles = new Map();
+    const lookup = (slug) => {
+        const handle = handles.get(slug);
+        if (!handle)
+            throw new RimeError(RimeError.INIT, `\`${slug}\` is not a registered prototype`);
+        return handle;
+    };
+    return {
+        registerPrototype: (config) => {
+            const table = baseTableName(config.slug);
+            // The point of registering rather than resolving per request: a missing table is a
+            // configuration or migration problem, and it should say so here.
+            if (!tables[table]) {
+                throw new RimeError(RimeError.INIT, `no table \`${table}\` for prototype \`${config.slug}\` — is the database migrated?`);
+            }
+            const args = { db, tables, configCtx, config, versions: config._versions };
+            handles.set(config.slug, config.type === 'area' ? createAreaHandle(args) : createCollectionHandle(args));
+        },
+        /**
+         * The two typed lookups.
+         *
+         * The cast is the erasure registration already makes, and sound for the same reason: a slug is
+         * registered under exactly one kind, and `config.type` is what picked the handle above. A
+         * caller holding a `BuiltCollection` asks for a collection; one holding a `BuiltArea` asks for
+         * an area.
+         */
+        collection: (slug) => lookup(slug),
+        area: (slug) => lookup(slug),
+        /**
+         * Where this prototype's content lives — its versions table where it has one, itself
+         * otherwise.
+         *
+         * Follows the `versions` each handle was registered with rather than rebuilding the slug from
+         * the naming convention, so the suffix stays the versions feature's to spell. A versioned
+         * prototype whose versions table never registered reaches `lookup` and throws, instead of
+         * falling back to the base table and writing content columns to a table that has none.
+         */
+        contentOwner: (slug) => {
+            const handle = lookup(slug);
+            return handle.versions ? lookup(handle.versions.slug) : handle;
+        }
+    };
+};

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

@@ -1,37 +1,35 @@
-import type { GenericAdapteFacadeArgs } from './types.server.js';
-import type { Relation } from '../fields/relation/index.js';
-declare const createRelationsFacade: ({ db, tables }: GenericAdapteFacadeArgs) => {
+import type { AdapterDeps } from './types.server.js';
+import type { BeforeOperationRelation, Relation } from '../fields/relation/index.js';
+import type { PrototypeSlug } from '../core/prototype/types.js';
+declare const createRelationsHandle: ({ db, tables }: AdapterDeps) => {
     create: Create;
     update: Update;
     delete: Delete;
     deleteFromPaths: DeleteFromPaths;
     getAll: GetAllRelations;
 };
-export default createRelationsFacade;
-export type BeforeOperationRelation = Omit<Relation, 'ownerId'> & {
-    ownerId?: string;
-};
+export default createRelationsHandle;
 type DeleteFromPaths = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     ownerId: string;
     paths: string[];
     locale?: string;
 }) => Promise<boolean>;
 type Delete = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     relations: Relation[];
 }) => Promise<boolean>;
 type Update = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     relations: Relation[];
 }) => Promise<boolean>;
 type Create = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     ownerId: string;
     relations: BeforeOperationRelation[];
 }) => Promise<boolean>;
 type GetAllRelations = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     ownerId: string;
     locale?: string;
 }) => Promise<Relation[]>;

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

@@ -1,12 +1,16 @@
+import { baseTableName, tableName } from './naming.server.js';
 import { omit } from '../util/object.js';
 import { and, eq, getTableColumns, inArray, isNull, or } from 'drizzle-orm';
-import { transformDataToSchema } from './util.server.js';
-const createRelationsFacade = ({ db, tables }) => {
+import { transformDataToSchema } from './columns.server.js';
+const createRelationsHandle = ({ db, tables }) => {
     //
     const deleteFromPaths = async ({ parentSlug, ownerId, paths, locale }) => {
         if (paths.length === 0)
             return true;
-        const relationTableName = `${parentSlug}Rels`;
+        const relationTableName = tableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'rels' }
+        });
         const table = tables[relationTableName];
         if (!table)
             return true;
@@ -32,7 +36,10 @@ const createRelationsFacade = ({ db, tables }) => {
         return true;
     };
     const create = async ({ parentSlug, ownerId, relations }) => {
-        const relationTableName = `${parentSlug}Rels`;
+        const relationTableName = tableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'rels' }
+        });
         const table = tables[relationTableName];
         const columns = getTableColumns(table);
         for (const relation of relations) {
@@ -60,7 +67,10 @@ const createRelationsFacade = ({ db, tables }) => {
         return true;
     };
     const update = async ({ parentSlug, relations }) => {
-        const relationTableName = `${parentSlug}Rels`;
+        const relationTableName = tableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'rels' }
+        });
         const table = tables[relationTableName];
         const columns = getTableColumns(table);
         try {
@@ -76,7 +86,10 @@ const createRelationsFacade = ({ db, tables }) => {
         return true;
     };
     const deleteRelations = async ({ parentSlug, relations }) => {
-        const relationTableName = `${parentSlug}Rels`;
+        const relationTableName = tableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'rels' }
+        });
         const table = tables[relationTableName];
         if (relations.length === 0)
             return true;
@@ -95,7 +108,10 @@ const createRelationsFacade = ({ db, tables }) => {
         return true;
     };
     const getAll = async ({ parentSlug, ownerId, locale }) => {
-        const relationTableName = `${parentSlug}Rels`;
+        const relationTableName = tableName({
+            owner: baseTableName(parentSlug),
+            child: { kind: 'rels' }
+        });
         // If the collection doesn't have relation
         // relationTableName doesn't exist
         // then there are no relations
@@ -125,4 +141,4 @@ const createRelationsFacade = ({ db, tables }) => {
         getAll
     };
 };
-export default createRelationsFacade;
+export default createRelationsHandle;

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

@@ -0,0 +1,36 @@
+import type { VersionsTable } from '../core/adapter.js';
+import type { BuiltArea, BuiltCollection } from '../core/config/types.js';
+import type { ConfigContext } from '../core/rime.server.js';
+import type { Dic } from '../util/types.js';
+/**
+ * What a handle builder is handed: the connection, the generated tables, and which config it is
+ * building a handle for.
+ *
+ * `read` carries `configCtx` because `findMany` resolves a query against the config's fields;
+ * `write` does not need it. `self` is the prototype's identity, which every call underneath
+ * re-stated before this existed.
+ */
+export type HandleDeps = {
+    db: any;
+    tables: Dic;
+    configCtx: ConfigContext;
+    config: BuiltArea | BuiltCollection;
+    versions?: VersionsTable;
+};
+/** The three bundles every verb in a handle passes down. */
+export declare const bundles: ({ db, tables, configCtx, config, versions }: HandleDeps) => {
+    write: {
+        db: any;
+        tables: Dic;
+    };
+    read: {
+        db: any;
+        tables: Dic;
+        configCtx: ConfigContext;
+    };
+    self: {
+        slug: never;
+        config: BuiltCollection | BuiltArea;
+        versions: VersionsTable | undefined;
+    };
+};

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

@@ -0,0 +1,6 @@
+/** The three bundles every verb in a handle passes down. */
+export const bundles = ({ db, tables, configCtx, config, versions }) => ({
+    write: { db, tables },
+    read: { db, tables, configCtx },
+    self: { slug: config.slug, config, versions }
+});

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

@@ -0,0 +1,25 @@
+import type { BuiltArea, BuiltCollection } from '../types.js';
+import type { Dic } from '../util/types.js';
+import { type TableName } from './naming.server.js';
+/**
+ * The `with` joining each resolved reference's target onto this table's rows.
+ *
+ * `table` is the base or the content table. A versioned config keeps its `$root()` references
+ * on the first and the rest on the second, so each table is asked only for its own. With a
+ * `select`, only the selected ones.
+ */
+export declare const resolvedReferenceJoins: (args: {
+    table: TableName;
+    tables: Dic;
+    config: BuiltCollection | BuiltArea;
+    select?: string[];
+}) => Dic;
+export declare const buildWithParam: (args: {
+    table: TableName;
+    select?: string[];
+    locale?: string;
+    /** The locales a read draws on, first to last — `localeOrder`. The requested one alone if absent. */
+    fallback?: string[];
+    tables: any;
+    config: BuiltCollection | BuiltArea;
+}) => Dic | undefined;