rimecms 0.33.0 → 1.0.0

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

@@ -1,28 +1,29 @@
-import { drizzle, LibSQLDatabase } from 'drizzle-orm/libsql';
 import path from 'path';
 import createAuthHandle from './auth.server.js';
 import createBlocksHandle from './blocks.server.js';
+import { connect } from './connect.server.js';
 import generateSchema from './generate-schema/index.server.js';
 import { baseTableName } from './naming.server.js';
+import createPathsHandle from './paths.server.js';
 import { createPrototypeRegistry } from './registry.server.js';
 import createRelationsHandle from './relations.server.js';
 import { createTableHandles } from './table.server.js';
 import { createTransformHandle } from './transform.server.js';
 import createTreeHandle from './tree.server.js';
-export function adapterSqlite(database) {
-    //
+export function adapterSqlite(database, options = {}) {
+    const driver = options.driver ?? 'libsql';
     return {
-        createAdapter: (configCtx) => createAdapter({ database, configCtx }),
+        createAdapter: (configCtx) => createAdapter({ database, driver, configCtx }),
         generateSchema
     };
 }
 const createAdapter = async (args) => {
-    const { database, configCtx } = args;
+    const { database, driver, configCtx } = args;
     const schema = (await import('$rime/schema'));
     const dbPath = path.join(process.cwd(), 'db', database);
     // `relations`, not `schema`: a relational query resolves through the one `defineRelations`
     // block the generator emits. `tables` is still read straight off the module everywhere else.
-    const db = drizzle('file:' + dbPath, { relations: schema.relations });
+    const db = await connect({ driver, dbPath, relations: schema.relations });
     const tables = schema.tables;
     // Two words, and each is the contract's own. `core/adapter.ts` declares `BlocksHandle`,
     // `TreeHandle`, `RelationsHandle`, `TransformHandle` and `AuthHandle` — one object of verbs
@@ -32,6 +33,7 @@ const createAdapter = async (args) => {
     const blocks = createBlocksHandle({ db, tables });
     const tree = createTreeHandle({ db, tables });
     const relations = createRelationsHandle({ db, tables });
+    const paths = createPathsHandle({ db, tables });
     const auth = createAuthHandle({
         db,
         schema: schema.default
@@ -48,6 +50,7 @@ const createAdapter = async (args) => {
         blocks,
         tree,
         relations,
+        paths,
         transform,
         auth,
         db,

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

@@ -10,6 +10,7 @@
  * child     pages__$relations                    hangs off an owner by `ownerId`
  *           pages__$blocks_hero                  one per block type
  *           pages__$tree_facts                   one per tree field
+ *           pages__$paths                        a page's address per locale, off the base table
  * branch    pages__$blocks_hero__$$locales       the localized half of whatever it hangs off
  * ```
  *
@@ -57,7 +58,7 @@ export declare const baseTableName: (slug: string) => TableName;
  * the SQL name is derived.
  */
 export declare const declaredTableProperty: (slug: string) => TableName;
-export type ChildKind = 'blocks' | 'tree' | 'rels';
+export type ChildKind = 'blocks' | 'tree' | 'rels' | 'paths';
 export type TableParts = {
     /**
      * The base or versions table this hangs off, already resolved.
@@ -66,7 +67,7 @@ export type TableParts = {
      * 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. */
+    /** A child table. `name` is the block type or the tree field; `rels` and `paths` have none. */
     child?: {
         kind: ChildKind;
         name?: string;
@@ -74,6 +75,8 @@ export type TableParts = {
     /** The localized half of whatever the parts above resolve to. */
     branch?: 'locales';
 };
+/** `pages__$paths` -> true: the addresses table a read joins off the base row. */
+export declare const isPathsTable: (name: string) => boolean;
 /**
  * Assembles a Drizzle property name from its parts.
  *
@@ -82,6 +85,7 @@ export type TableParts = {
  * 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'
+ * tableName({ owner: pages, child: { kind: 'paths' } })         // 'pages__$paths'
  */
 export declare const tableName: (parts: TableParts) => TableName;
 /**
@@ -93,12 +97,6 @@ export declare const tableName: (parts: TableParts) => TableName;
  * 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.

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

@@ -23,8 +23,11 @@ export const declaredTableProperty = (slug) => slug.replace(/^\$/, '');
 const CHILD_MARKER = {
     blocks: '__$blocks',
     tree: '__$tree',
-    rels: '__$relations'
+    rels: '__$relations',
+    paths: '__$paths'
 };
+/** `pages__$paths` -> true: the addresses table a read joins off the base row. */
+export const isPathsTable = (name) => name.endsWith(CHILD_MARKER.paths);
 /** `__$$` marks a branch: the half of a table holding its localized columns. */
 const BRANCH_MARKER = '__$$locales';
 /**
@@ -35,6 +38,7 @@ const BRANCH_MARKER = '__$$locales';
  * 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'
+ * tableName({ owner: pages, child: { kind: 'paths' } })         // 'pages__$paths'
  */
 export const tableName = (parts) => {
     let name = parts.owner;
@@ -60,10 +64,24 @@ export const toSqlTableName = (drizzleName) => drizzleName;
  * 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.
  */
+const childTablesMemo = new WeakMap();
 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 schema does not change once loaded, and this is asked several times per query and twice
+    // per document read: answered once per schema, owner and kind.
+    let byOwner = childTablesMemo.get(tables);
+    if (!byOwner) {
+        byOwner = new Map();
+        childTablesMemo.set(tables, byOwner);
+    }
+    const key = `${owner}|${kind}`;
+    let names = byOwner.get(key);
+    if (!names) {
+        const prefix = tableName({ owner, child: { kind } });
+        // Keys of the generated schema: table names by construction.
+        names = Object.keys(tables).filter((key) => key.startsWith(prefix) && !key.endsWith(BRANCH_MARKER));
+        byOwner.set(key, names);
+    }
+    return names;
 };
 /**
  * The relation key a resolved reference's target is joined under.

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

@@ -0,0 +1,10 @@
+import type { PathsHandle } from '../core/adapter.js';
+import type { AdapterDeps } from './types.server.js';
+/**
+ * The addresses of a collection's pages, in its `__$paths` table.
+ *
+ * Every statement names one page. The pages under it follow through the foreign key on
+ * `(locale, parent_path)`: SQLite rewrites their `parent_path`, which regenerates their `path`.
+ */
+declare const createPathsHandle: ({ db, tables }: AdapterDeps) => PathsHandle;
+export default createPathsHandle;

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

@@ -0,0 +1,122 @@
+import { and, eq, gt, isNull, lt, notInArray, or, sql } from 'drizzle-orm';
+import { alias } from 'drizzle-orm/sqlite-core';
+import { baseTableName, tableName } from './naming.server.js';
+/**
+ * The addresses of a collection's pages, in its `__$paths` table.
+ *
+ * Every statement names one page. The pages under it follow through the foreign key on
+ * `(locale, parent_path)`: SQLite rewrites their `parent_path`, which regenerates their `path`.
+ */
+const createPathsHandle = ({ db, tables }) => {
+    const tablesOf = (slug) => {
+        const base = baseTableName(slug);
+        return {
+            base: tables[base],
+            paths: tables[tableName({ owner: base, child: { kind: 'paths' } })]
+        };
+    };
+    /** The parent's path in `locale`: a subquery, so the write stays one statement. */
+    const parentPathIn = (paths, parentId, locale) => {
+        const parent = alias(paths, 'parent');
+        return sql `(${db
+            .select({ path: parent.path })
+            .from(parent)
+            .where(and(eq(parent.ownerId, parentId), sql `${parent.locale} = ${locale}`))})`;
+    };
+    const rowsOf = (rows) => rows;
+    return {
+        insert: async ({ slug, ownerId, parentId, rows }) => {
+            if (!rows.length)
+                return [];
+            const { paths } = tablesOf(slug);
+            const inserted = await db
+                .insert(paths)
+                .values(rows.map((row) => ({
+                ownerId,
+                locale: row.locale,
+                slug: row.slug,
+                parentPath: parentId ? parentPathIn(paths, parentId, row.locale) : null
+            })))
+                .returning();
+            return rowsOf(inserted);
+        },
+        get: async ({ slug, ownerId, locale }) => {
+            const { paths } = tablesOf(slug);
+            const where = locale === undefined
+                ? eq(paths.ownerId, ownerId)
+                : and(eq(paths.ownerId, ownerId), eq(paths.locale, locale));
+            return rowsOf(await db.select().from(paths).where(where));
+        },
+        setSlug: async ({ slug, ownerId, locale, value }) => {
+            const { paths } = tablesOf(slug);
+            const [row] = await db
+                .update(paths)
+                .set({ slug: value })
+                .where(and(eq(paths.ownerId, ownerId), eq(paths.locale, locale)))
+                .returning();
+            return row;
+        },
+        // One statement for every locale: each row takes its new parent's path in its own locale.
+        moveUnder: async ({ slug, ownerId, parentId }) => {
+            const { paths } = tablesOf(slug);
+            const moved = await db
+                .update(paths)
+                .set({ parentPath: parentId ? parentPathIn(paths, parentId, paths.locale) : null })
+                .where(eq(paths.ownerId, ownerId))
+                .returning();
+            return rowsOf(moved);
+        },
+        detachChildren: async ({ slug, ownerId }) => {
+            const { paths } = tablesOf(slug);
+            const self = alias(paths, 'self');
+            const detached = await db
+                .update(paths)
+                .set({ parentPath: null })
+                .where(sql `(${paths.locale}, ${paths.parentPath}) IN (${db
+                .select({ locale: self.locale, path: self.path })
+                .from(self)
+                .where(eq(self.ownerId, ownerId))})`)
+                .returning();
+            return rowsOf(detached);
+        },
+        // `path/` <= p < `path0` is every path starting with `path/`, read off the unique index:
+        // '0' is the character after '/'.
+        under: async ({ slug, locale, path, withDescendants = true }) => {
+            const { paths } = tablesOf(slug);
+            const below = and(gt(paths.path, `${path}/`), lt(paths.path, `${path}0`));
+            const where = and(eq(paths.locale, locale), withDescendants ? or(eq(paths.path, path), below) : eq(paths.path, path));
+            return rowsOf(await db.select().from(paths).where(where));
+        },
+        siblingSlugs: async ({ slug, locale, parentId }) => {
+            const { paths } = tablesOf(slug);
+            const parent = parentId
+                ? sql `${paths.parentPath} = ${parentPathIn(paths, parentId, locale)}`
+                : isNull(paths.parentPath);
+            const rows = await db
+                .select({ slug: paths.slug })
+                .from(paths)
+                .where(and(eq(paths.locale, locale), parent));
+            return rows.map((row) => row.slug);
+        },
+        missingOwners: async ({ slug, locale }) => {
+            const { base, paths } = tablesOf(slug);
+            const owned = db.select({ id: paths.ownerId }).from(paths).where(eq(paths.locale, locale));
+            const rows = await db.select({ id: base.id }).from(base).where(notInArray(base.id, owned));
+            return rows.map((row) => row.id);
+        },
+        setUrls: async ({ slug, rows }) => {
+            if (!rows.length)
+                return;
+            const { paths } = tablesOf(slug);
+            await db.transaction(async (tx) => {
+                for (const { ownerId, locale, url } of rows) {
+                    await tx
+                        .update(paths)
+                        .set({ url })
+                        .where(and(eq(paths.ownerId, ownerId), eq(paths.locale, locale)));
+                }
+            });
+        }
+    };
+};
+export default createPathsHandle;

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

@@ -28,6 +28,13 @@ type ReadArgs = {
     locale?: string;
     /** Whether an untranslated field reads from the other locales. `true` unless said otherwise. */
     localeFallback?: boolean;
+    /**
+     * The resolved references to join, by document path — a `$references(slug, { resolve: true })`
+     * field comes back as the document it points at only when its path is here. Every one when
+     * absent; `select` narrows further. The caller lists what its reader may see, so a row is never
+     * joined for a field the pipeline goes on to drop.
+     */
+    resolve?: string[];
     /** Which content row, when the caller means a particular one. The newest otherwise. */
     content?: OperationQuery;
     config: BuiltCollection | BuiltArea;
@@ -46,7 +53,7 @@ type ReadArgs = {
  * 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 readPrototype: ({ db, tables, configCtx }: DepsWithConfig, { slug, id, select, resolve, 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 = {
@@ -60,6 +67,8 @@ type FindManyArgs = {
     locale?: string;
     /** See `readPrototype`. */
     localeFallback?: boolean;
+    /** See `readPrototype`. */
+    resolve?: string[];
     /** Per document, which content row — see `readPrototype`. */
     content?: OperationQuery;
     config: BuiltCollection | BuiltArea;

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

@@ -6,7 +6,7 @@ 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';
+import { buildWithParam, pathsJoin, resolvedReferenceJoins } from './select.server.js';
 /**
  * Reads one prototype document, merged with the content row it should show.
  *
@@ -21,7 +21,7 @@ import { buildWithParam, resolvedReferenceJoins } from './select.server.js';
  * 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 }) => {
+export const readPrototype = async ({ db, tables, configCtx }, { slug, id, select, resolve, locale, localeFallback, content, config, versions }) => {
     const table = baseTableName(slug);
     const rootTable = tables[table];
     const fallback = localeOrder(configCtx, locale, localeFallback);
@@ -34,7 +34,7 @@ export const readPrototype = async ({ db, tables, configCtx }, { slug, id, selec
         return queryTable.findFirst({
             columns: adapterUtil.columnsParams({ table: rootTable, select }),
             ...byId,
-            with: buildWithParam({ table, select, locale, fallback, tables, config }) || undefined
+            with: buildWithParam({ table, select, resolve, locale, fallback, tables, config }) || undefined
         });
     }
     // See findManyPrototypes for why the versions table's slug is castable.
@@ -44,11 +44,21 @@ export const readPrototype = async ({ db, tables, configCtx }, { slug, id, selec
         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 }),
+            // The base row's own resolved references and address; the content row's come with
+            // `buildWithParam`.
+            ...resolvedReferenceJoins({ table, tables, config, select, resolve }),
+            ...pathsJoin({ base: table, tables, locale, select }),
             [contentTable]: {
                 columns: adapterUtil.columnsParams({ table: tables[contentTable], select }),
-                with: buildWithParam({ table: contentTable, select, locale, fallback, tables, config }),
+                with: buildWithParam({
+                    table: contentTable,
+                    select,
+                    resolve,
+                    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`).
@@ -83,7 +93,7 @@ export const readPrototype = async ({ db, tables, configCtx }, { slug, id, selec
     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;
+    const { select, resolve, 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;
@@ -93,7 +103,7 @@ export const findManyPrototypes = async ({ db, tables, configCtx }, args) => {
     // 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,
+            with: buildWithParam({ table, select, resolve, 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),
@@ -119,7 +129,8 @@ export const findManyPrototypes = async ({ db, tables, configCtx }, args) => {
     // 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;
+    const withParam = buildWithParam({ table: contentTable, select, resolve, 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
@@ -161,7 +172,8 @@ export const findManyPrototypes = async ({ db, tables, configCtx }, args) => {
         ...params,
         columns: adapterUtil.columnsParams({ table: tables[table], select }),
         with: {
-            ...resolvedReferenceJoins({ table, tables, config, select }),
+            ...resolvedReferenceJoins({ table, tables, config, select, resolve }),
+            ...pathsJoin({ base: table, tables, locale, select }),
             [contentTable]: {
                 with: withParam,
                 where: { RAW: contentWhere },

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

@@ -13,10 +13,29 @@ export declare const resolvedReferenceJoins: (args: {
     tables: Dic;
     config: BuiltCollection | BuiltArea;
     select?: string[];
+    /** The references to join at all, by path; every one when absent. */
+    resolve?: string[];
+}) => Dic;
+/**
+ * The page's row in its paths table, in the locale read, when its collection has `$url`. A page
+ * has a row in every locale, so there is no fallback to resolve.
+ *
+ * ```ts
+ * pathsJoin({ base: 'pages', tables, locale: 'en' })
+ * // { 'pages__$paths': { where: { locale: 'en' }, columns: { slug: true, path: true, url: true } } }
+ * ```
+ */
+export declare const pathsJoin: (args: {
+    base: TableName;
+    tables: Dic;
+    locale?: string;
+    select?: string[];
 }) => Dic;
 export declare const buildWithParam: (args: {
     table: TableName;
     select?: string[];
+    /** See `resolvedReferenceJoins`. */
+    resolve?: string[];
     locale?: string;
     /** The locales a read draws on, first to last — `localeOrder`. The requested one alone if absent. */
     fallback?: string[];