rimecms 0.33.0 → 1.0.1

package/dist/adapter-sqlite/generate-schema/templates.server.js

@@ -1,20 +1,20 @@
 import { toSnakeCase } from '../../util/string.js';
-import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName } from '../naming.server.js';
 import dedent from 'dedent';
+import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName, tableName } from '../naming.server.js';
 const s = toSnakeCase;
 /**
  * Generates the standard imports needed for Drizzle ORM schema definitions
  * Includes SQLite table definitions, relations, and a primary key helper function
  */
 export const templateImports = `
-import { text, integer, sqliteTable, real } from "drizzle-orm/sqlite-core";
-import { defineRelations } from 'drizzle-orm';
+import { text, integer, sqliteTable, real, index, unique, check, foreignKey } from "drizzle-orm/sqlite-core";
+import { defineRelations, sql } from 'drizzle-orm';
 
 const pk = () => text("id").primaryKey().$defaultFn(() => crypto.randomUUID());
 `;
 /**
  * Generates a basic table definition with a primary key
- * Takes a table name and optional content for additional columns
+ * Takes a table name, its columns, and the columns to index
  *
  * @example
  * ```typescript
@@ -22,18 +22,29 @@ const pk = () => text("id").primaryKey().$defaultFn(() => crypto.randomUUID());
  *   id: pk(),
  *   title: text('title'),
  *   content: text('content')
- * })
+ * }, (t) => [index('pages_updated_at_idx').on(t.updatedAt)])
  * ```
  */
-export const templateTable = (table, content) => {
+export const templateTable = (table, content, indexed = []) => {
     if (!content.includes('id:')) {
         content = `id: pk(),\n${content}`;
     }
     return `export const ${table} = sqliteTable( '${table}', {
 		${content}
-	})
+	}${templateIndexes(table, indexed)})
 	`;
 };
+/**
+ * One index per column, named after the table and the column.
+ *
+ * ```ts
+ * templateIndexes('pages__$rels', ['ownerId', 'mediasId'])
+ * // , (t) => [index('pages__$rels_owner_id_idx').on(t.ownerId), index('pages__$rels_medias_id_idx').on(t.mediasId)]
+ * ```
+ */
+export const templateIndexes = (table, columns) => columns.length
+    ? `, (t) => [${columns.map((column) => `index('${table}_${s(column)}_idx').on(t.${column})`).join(', ')}]`
+    : '';
 /**
  * Generates a locale field for internationalized tables
  *
@@ -160,12 +171,44 @@ export const templateUniqueRequired = (field, defaultValue) => {
  * ```
  */
 const templateDefault = (value) => value instanceof Date ? `new Date(${value.getTime()})` : JSON.stringify(value);
+/**
+ * The addresses of a collection with `$url`: one row per page and per locale, off its base table.
+ *
+ * `path` is generated from the parent's path and the slug. Renaming or moving a row carries down
+ * its subtree, through the foreign key on `(locale, parent_path)`.
+ *
+ * ```ts
+ * export const pages__$paths = sqliteTable('pages__$paths', { …, path: text('path').generatedAlwaysAs(…) }, …)
+ * ```
+ */
+export const templatePathsTable = (owner) => {
+    const table = tableName({ owner, child: { kind: 'paths' } });
+    return `
+export const ${table} = sqliteTable('${table}', {
+  id: pk(),
+  ownerId: text('owner_id').notNull().references(() => ${owner}.id, { onDelete: 'cascade' }),
+  locale: text('locale').notNull(),
+  slug: text('slug').notNull(),
+  parentPath: text('parent_path'),
+  path: text('path').generatedAlwaysAs(sql\`coalesce(parent_path || '/', '') || slug\`, { mode: 'stored' }),
+  url: text('url')
+}, (t) => [
+  unique('${table}_owner_locale').on(t.ownerId, t.locale),
+  unique('${table}_path').on(t.locale, t.path),
+  index('${table}_parent_idx').on(t.locale, t.parentPath),
+  index('${table}_url_idx').on(t.locale, t.url),
+  check('${table}_slug', sql\`slug <> ''\`),
+  foreignKey({ columns: [t.locale, t.parentPath], foreignColumns: [t.locale, t.path] }).onUpdate('cascade')
+]);
+`;
+};
 /** Template rows Relation */
 /**
- * The whole schema's relations, in one declaration.
+ * The drizzle relations of the whole schema. A read lists them in its `with` to load related rows
+ * in the same query, by the names given here.
  *
- * Every relation rime generates is the same shape — a child row points at its owner through
- * `ownerId` — so the tree is `parent -> children` and both directions fall out of it:
+ * A child table (blocks, tree…) points at its owner through `ownerId`. It gets a relation each way,
+ * named after the table on the other end:
  *
  * ```ts
  * export const relations = defineRelations(tables, (r) => ({
@@ -180,14 +223,13 @@ const templateDefault = (value) => value instanceof Date ? `new Date(${value.get
  * }));
  * ```
  *
- * A relation is keyed by the table on the other end, which is what `buildWithParam` names when it
- * builds a `with`.
- *
- * A reference the read resolves is the other shape: the owner's row points at its target through
- * the field's own column, one direction, keyed by `joinName(column)`:
+ * A reference field that stores another document's id in its own column: `updatedBy` holds a staff id.
+ * It gets one relation, from that column to the target, named after the column. Two columns can
+ * point at the same table:
  *
  * ```ts
  * pages: {
+ *   createdBy__$doc: r.one.staff({ from: r.pages.createdBy, to: r.staff.id }),
  *   updatedBy__$doc: r.one.staff({ from: r.pages.updatedBy, to: r.staff.id })
  * }
  * ```
@@ -234,7 +276,7 @@ export const templateFieldRelationColumn = (slug) => {
 };
 /**
  * Generates a junction table for many-to-many relationships
- * Creates a table with references to the owner table and related tables
+ * Creates a table with references to the owner table and related tables, each one indexed
  * Includes path and position fields for ordering relationships
  *
  * @example
@@ -246,7 +288,7 @@ export const templateFieldRelationColumn = (slug) => {
  *   ownerId: text('owner_id').references(() => pages.id, { onDelete: 'cascade' }),
  *   mediasId: text('medias_id').references(() => medias.id, { onDelete: 'cascade' }),
  *   locale: text('locale'),
- * })
+ * }, (t) => [index('pages_rels_owner_id_idx').on(t.ownerId), index('pages_rels_medias_id_idx').on(t.mediasId)])
  * ```
  */
 export const templateRelationFieldsTable = ({ table, junctionTable, relations, hasLocale }) => `
@@ -257,7 +299,7 @@ export const ${junctionTable} = sqliteTable('${junctionTable}', {
   ${templateParent(table)}
   ${relations.map((rel) => templateFieldRelationColumn(rel)).join(',\n')},
   ${hasLocale ? `locale: text('locale'),` : ''}
-})
+}${templateIndexes(junctionTable, ['ownerId', ...relations.map((rel) => `${rel}Id`)])})
 `;
 /**
  * Generates an export of relation field mappings for runtime use

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

@@ -2,12 +2,21 @@ import type { Adapter } from '../core/adapter.js';
 import type { Config } from '../core/config/types.js';
 import type { ConfigContext } from '../core/rime.server.js';
 import type { GetRegisterType } from '../index.js';
-import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type SqliteDriver } from './connect.server.js';
 import generateSchema from './generate-schema/index.server.js';
 import type { RelationFieldsMap } from './generate-schema/root.server.js';
-import type { GenericTable } from './types.server.js';
+import type { GenericTable, SqliteDatabase } from './types.server.js';
 type Schema = GetRegisterType<'Schema'>;
-export declare function adapterSqlite(database: string): {
+export type { SqliteDriver };
+export type AdapterSqliteOptions = {
+    /**
+     * `'bun'` opens the file with `bun:sqlite` — the app must then run on Bun
+     * (`bun --bun vite dev`, `bun index.js`). Migrations still go through drizzle-kit.
+     * @default 'libsql'
+     */
+    driver?: SqliteDriver;
+};
+export declare function adapterSqlite(database: string, options?: AdapterSqliteOptions): {
     createAdapter: <C extends Config>(configCtx: ConfigContext<C>) => Promise<SqliteAdapter>;
     generateSchema: typeof generateSchema;
 };
@@ -23,11 +32,10 @@ export declare function adapterSqlite(database: string): {
  * that drifts from the contract is a build error rather than a runtime surprise.
  */
 export type SqliteAdapter = Adapter & {
-    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
+    db: SqliteDatabase;
     tables: GetRegisterType<'Tables'>;
     getTable<T>(key: string): T extends any ? GenericTable : T;
     tableForSlug<T>(slug: string): T extends any ? GenericTable : T;
     readonly schema: Schema;
     readonly relationFieldsMap: RelationFieldsMap;
 };
-export {};

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,131 @@
+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 per locale, in one transaction: each row takes its new parent's path in its
+        // locale, and its slug there.
+        moveUnder: async ({ slug, ownerId, parentId, slugs }) => {
+            const { paths } = tablesOf(slug);
+            return db.transaction(async (tx) => {
+                const moved = [];
+                for (const [locale, value] of Object.entries(slugs)) {
+                    const rows = await tx
+                        .update(paths)
+                        .set({
+                        slug: value,
+                        parentPath: parentId ? parentPathIn(paths, parentId, locale) : null
+                    })
+                        .where(and(eq(paths.ownerId, ownerId), eq(paths.locale, locale)))
+                        .returning();
+                    moved.push(...rows);
+                }
+                return rowsOf(moved);
+            });
+        },
+        children: async ({ slug, ownerId }) => {
+            const { paths } = tablesOf(slug);
+            const self = alias(paths, 'self');
+            const rows = await db
+                .selectDistinct({ ownerId: paths.ownerId })
+                .from(paths)
+                .where(sql `(${paths.locale}, ${paths.parentPath}) IN (${db
+                .select({ locale: self.locale, path: self.path })
+                .from(self)
+                .where(eq(self.ownerId, ownerId))})`);
+            return rows.map((row) => row.ownerId);
+        },
+        // `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/rows.server.d.ts

@@ -30,7 +30,7 @@ export declare const bundles: ({ db, tables, configCtx, config, versions }: Hand
     };
     self: {
         slug: never;
-        config: BuiltCollection | BuiltArea;
+        config: BuiltArea | BuiltCollection;
         versions: VersionsTable | undefined;
     };
 };

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[];