rimecms 0.31.4 → 0.32.0

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

@@ -1,5 +1,5 @@
-import { withDirectoriesSuffix } from '../../core/naming.js';
 import { toSnakeCase } from '../../util/string.js';
+import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName } from '../naming.server.js';
 import dedent from 'dedent';
 const s = toSnakeCase;
 /**
@@ -8,7 +8,7 @@ const s = toSnakeCase;
  */
 export const templateImports = `
 import { text, integer, sqliteTable, real } from "drizzle-orm/sqlite-core";
-import { relations } from 'drizzle-orm';
+import { defineRelations } from 'drizzle-orm';
 
 const pk = () => text("id").primaryKey().$defaultFn(() => crypto.randomUUID());
 `;
@@ -29,7 +29,7 @@ export const templateTable = (table, content) => {
     if (!content.includes('id:')) {
         content = `id: pk(),\n${content}`;
     }
-    return `export const ${table} = sqliteTable( '${s(table)}', {
+    return `export const ${table} = sqliteTable( '${table}', {
 		${content}
 	})
 	`;
@@ -66,28 +66,69 @@ export const templateParent = (parent) => {
  * ```
  */
 export const templateReferences = ({ table, onDelete, onUpdate, selfReferencing }) => {
+    // `table` is a prototype *slug* — every $references caller passes one (auth: 'staff',
+    // the prototype's own slug, or a derived one). Resolving it here keeps
+    // features out of table naming, which is the adapter's business.
+    const referenced = baseTableName(table);
     const arrow = selfReferencing ? '(): any =>' : '() =>';
     const opts = [
         onDelete ? `onDelete: '${onDelete}'` : '',
         onUpdate ? `onUpdate: '${onUpdate}'` : ''
     ].filter(Boolean);
     const optsStr = opts.length ? `, { ${opts.join(', ')} }` : '';
-    return `.references(${arrow} ${table}.id${optsStr})`;
+    return `.references(${arrow} ${referenced}.id${optsStr})`;
 };
 /**
- * Generates authentication-related fields for a table
- * Adds super admin flag for the panel users table
+ * How a declared `ColumnType` is spelled in drizzle. The whole of what the adapter knows about a
+ * feature's storage: six shapes, none of them named after anything.
+ */
+const COLUMN_EXPR = {
+    text: (snake) => `text('${snake}')`,
+    integer: (snake) => `integer('${snake}')`,
+    real: (snake) => `real('${snake}')`,
+    boolean: (snake) => `integer('${snake}', { mode: 'boolean' })`,
+    timestamp: (snake) => `integer('${snake}', { mode: 'timestamp' })`,
+    timestampMs: (snake) => `integer('${snake}', { mode: 'timestamp_ms' })`,
+    json: (snake) => `text('${snake}', { mode: 'json' })`
+};
+/**
+ * One column of a `TableDeclaration`, or one a feature puts on a prototype's own table.
+ *
+ * A `references` names a slug, so it resolves here — the same rule `templateReferences` follows
+ * for a field-level foreign key, and for the same reason: which table a slug lives in is the
+ * adapter's business.
  *
  * @example
  * ```typescript
- * authUserId: text("auth_user_id").references(() => authUsers.id).notNull(),
+ * authUserId: text('auth_user_id').notNull().references(() => authUsers.id, { onDelete: 'cascade' })
  * ```
  */
-export const templateHasAuth = (slug) => {
-    return `authUserId: text("auth_user_id").references(() => authUsers.id, { onDelete: 'cascade' }).notNull(),
-${slug === 'staff' ? `isSuperAdmin: integer('is_super_admin', { mode: 'boolean' }),` : ''}
-`;
+export const templateDeclaredColumn = (column) => {
+    const { camel, snake } = getSchemaColumnNames({ name: column.name });
+    const references = column.references
+        ? `.references(() => ${declaredTableProperty(column.references.table)}.${column.references.column ?? 'id'}, { onDelete: '${column.references.onDelete ?? 'cascade'}' })`
+        : '';
+    return [
+        `${camel}: ${COLUMN_EXPR[column.type](snake)}`,
+        column.primary ? '.primaryKey()' : '',
+        column.notNull ? '.notNull()' : '',
+        column.unique ? '.unique()' : '',
+        column.defaultValue !== undefined ? `.default(${JSON.stringify(column.defaultValue)})` : '',
+        references
+    ].join('');
 };
+/**
+ * A table a feature declared: `templateAuth`, `templateAPIKey` and `templateDirectories` were
+ * three hand-written copies of this, and the schema generator had to know each by name to push it.
+ *
+ * Exported under the slug's own name and stored under the snake-cased one — see
+ * `declaredTableProperty`. No `pk()` default: a declaration says which column is the primary key.
+ */
+export const templateDeclaredTable = (table) => `
+export const ${declaredTableProperty(table.slug)} = sqliteTable('${baseTableName(table.slug)}', {
+  ${table.columns.map(templateDeclaredColumn).join(',\n  ')}
+});
+`;
 /**
  * Generates unique and required modifiers for a field
  * Combines .unique() and .notNull() based on field configuration
@@ -111,44 +152,60 @@ export const templateUniqueRequired = (field, defaultValue) => {
 };
 /** Template rows Relation */
 /**
- * Generates a one-to-one or many-to-one relationship definition
- * Creates a relation where the table has one parent
+ * The whole schema's relations, in one declaration.
  *
- * @example
- * ```typescript
- * export const rel_pagesVersionsHasOnePages = relations(pagesVersions, ({ one }) => ({
- *   pages: one(pages, {
- *     fields: [pagesVersions.ownerId],
- *     references: [pages.id],
- *   }),
- * }))
+ * 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:
+ *
+ * ```ts
+ * export const relations = defineRelations(tables, (r) => ({
+ *   pages: {
+ *     pages__$blocks_paragraph: r.many.pages__$blocks_paragraph({
+ *       from: r.pages.id, to: r.pages__$blocks_paragraph.ownerId
+ *     })
+ *   },
+ *   pages__$blocks_paragraph: {
+ *     pages: r.one.pages({ from: r.pages__$blocks_paragraph.ownerId, to: r.pages.id })
+ *   }
+ * }));
  * ```
- */
-export const templateRelationOne = ({ name, table, parent }) => `
-export const ${name} = relations(${table}, ({ one }) => ({
-  ${parent} : one(${parent}, {
-    fields: [${table}.ownerId],
-    references: [${parent}.id],
-  }),
-}))
-`;
-/**
- * Generates a one-to-many relationship definition
- * Creates a relation where the table has many children
  *
- * @example
- * ```typescript
- * export const rel_pagesHasManyBlocks = relations(pages, ({ many }) => ({
- *   pagesBlocksParagraph: many(pagesBlocksParagraph),
- *   pagesBlocksImage: many(pagesBlocksImage),
- * }))
+ * 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)`:
+ *
+ * ```ts
+ * pages: {
+ *   updatedBy__$doc: r.one.staff({ from: r.pages.updatedBy, to: r.staff.id })
+ * }
  * ```
  */
-export const templateRelationMany = ({ name, table, many }) => `
-export const ${name} = relations(${table}, ({ many }) => ({
-  ${many.map((child) => `${child}: many(${child}),`).join('\n')}
-}))
+export const templateRelations = (tree, referenceJoins = []) => {
+    /** table -> its relation lines. A table is often both a parent and a child. */
+    const lines = {};
+    const add = (table, key, line) => {
+        (lines[table] ??= new Map()).set(key, line);
+    };
+    for (const [parent, children] of Object.entries(tree)) {
+        for (const child of children) {
+            add(parent, child, `${child}: r.many.${child}({ from: r.${parent}.id, to: r.${child}.ownerId })`);
+            add(child, parent, `${parent}: r.one.${parent}({ from: r.${child}.ownerId, to: r.${parent}.id })`);
+        }
+    }
+    for (const { table, column, to } of referenceJoins) {
+        const target = baseTableName(to);
+        const key = joinName(column);
+        add(table, key, `${key}: r.one.${target}({ from: r.${table}.${column}, to: r.${target}.id })`);
+    }
+    const entries = Object.entries(lines).map(([table, rels]) => `  ${table}: {\n    ${[...rels.values()].join(',\n    ')}\n  }`);
+    return `
+export const relations = defineRelations(tables, (r) => ({
+${entries.join(',\n')}
+}));
 `;
+};
 /** Templates Field Relations */
 /**
  * Generates a foreign key column for a relation field
@@ -179,8 +236,8 @@ export const templateFieldRelationColumn = (table) => {
  * })
  * ```
  */
-export const templateRelationFieldsTable = ({ table, relations, hasLocale }) => `
-export const ${table}Rels = sqliteTable('${s(table)}_rels', {
+export const templateRelationFieldsTable = ({ table, junctionTable, relations, hasLocale }) => `
+export const ${junctionTable} = sqliteTable('${junctionTable}', {
   id: pk(),
   path: text('path'),
   position: integer('position'),
@@ -222,112 +279,16 @@ export const templateExportRelationsFieldsToTable = (relationFieldsDic) => {
  * export const tables = {
  *   pages,
  *   pagesBlocksParagraph,
- *   pagesBlocksImage,
- *   authUsers,
- *   authAccounts,
- *   authVerifications,
- *   authSessions
+ *   pagesBlocksImage
  * }
  * ```
  */
 export const templateExportTables = (tables) => dedent `
 
   export const tables = {
-    ${tables.join(',\n    ')},
-    authUsers,
-    authAccounts,
-    authVerifications,
-    authSessions
+    ${tables.join(',\n    ')}
   }
 `;
-/**
- * Generates authentication tables for the schema
- * Creates tables for users, sessions, accounts, and verifications
- */
-export const templateAuth = `
-export const authUsers = sqliteTable('auth_users', {
-	id: text('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull().unique(),
-	emailVerified: integer('email_verified', { mode: 'boolean' }).notNull(),
-	image: text('image'),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
-	role: text('role'),
-	banned: integer('banned', { mode: 'boolean' }),
-	banReason: text('ban_reason'),
-	banExpires: integer('ban_expires', { mode: 'timestamp_ms' }),
-	type: text('type').notNull()
-  });
-
-export const authSessions = sqliteTable('auth_sessions', {
-	id: text('id').primaryKey(),
-	expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
-	token: text('token').notNull().unique(),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
-	ipAddress: text('ip_address'),
-	userAgent: text('user_agent'),
-	userId: text('user_id')
-		.notNull()
-		.references(() => authUsers.id, { onDelete: 'cascade' }),
-	impersonatedBy: text('impersonated_by')
-  });
-
-export const authAccounts = sqliteTable('auth_accounts', {
-	id: text('id').primaryKey(),
-	accountId: text('account_id').notNull(),
-	issuer: text('issuer').notNull(),
-	providerId: text('provider_id').notNull(),
-	userId: text('user_id')
-		.notNull()
-		.references(() => authUsers.id, { onDelete: 'cascade' }),
-	accessToken: text('access_token'),
-	refreshToken: text('refresh_token'),
-	idToken: text('id_token'),
-	accessTokenExpiresAt: integer('access_token_expires_at', { mode: 'timestamp_ms' }),
-	refreshTokenExpiresAt: integer('refresh_token_expires_at', { mode: 'timestamp_ms' }),
-	scope: text('scope'),
-	password: text('password'),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull()
-  });
-
-export const authVerifications = sqliteTable('auth_verifications', {
-	id: text('id').primaryKey(),
-	identifier: text('identifier').notNull(),
-	value: text('value').notNull(),
-	expiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' }),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
-  });
-`;
-export const templateAPIKey = `
-export const apikey = sqliteTable("apikey", {
-	id: text('id').primaryKey(),
-	name: text('name'),
-	start: text('start'),
-	prefix: text('prefix'),
-	key: text('key').notNull(),
-	referenceId: text('reference_id').notNull().references(()=> authUsers.id, { onDelete: 'cascade' }),
-	configId: text('config_id').notNull().default('default'),
-	refillInterval: integer('refill_interval'),
-	refillAmount: integer('refill_amount'),
-	lastRefillAt: integer('last_refill_at', { mode: 'timestamp' }),
-	enabled: integer('enabled', { mode: 'boolean' }).default(true),
-	rateLimitEnabled: integer('rate_limit_enabled', { mode: 'boolean' }).default(true),
-	rateLimitTimeWindow: integer('rate_limit_time_window').default(86400000),
-	rateLimitMax: integer('rate_limit_max').default(10),
-	requestCount: integer('request_count'),
-	remaining: integer('remaining'),
-	lastRequest: integer('last_request', { mode: 'timestamp' }),
-	expiresAt: integer('expires_at', { mode: 'timestamp' }),
-	createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
-	updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
-	permissions: text('permissions'),
-	metadata: text('metadata')
-});
-`;
 /**
  * Generates the final schema export with all tables and relations
  * Creates a schema object and exports it with proper TypeScript types
@@ -336,13 +297,9 @@ export const apikey = sqliteTable("apikey", {
  * ```typescript
  * const schema = {
  *   pages,
- *   pagesVersions,
- *   rel_pagesVersionsHasOnePages,
- *   rel_pagesHasManyVersions,
- *   authUsers,
- *   authAccounts,
- *   authVerifications,
- *   authSessions
+ *   pagesShadow,
+ *   rel_pagesShadowHasOnePages,
+ *   rel_pagesHasManyShadow
  * }
  *
  * declare module 'rimecms' {
@@ -353,20 +310,16 @@ export const apikey = sqliteTable("apikey", {
  * export default schema
  * ```
  */
-export const templateExportSchema = ({ enumTables, enumRelations }) => `
+export const templateExportSchema = ({ enumTables }) => `
 const schema = {
-	${enumTables.join(',\n      ')},
-	${enumRelations.length ? enumRelations.join(',\n      ') + ',' : ''}
-	authUsers,
-	authAccounts,
-	authVerifications,
-	authSessions
+	${enumTables.join(',\n      ')}
 }
 
 declare module 'rimecms' {
 	export interface RegisterSchema {
 			schema: typeof schema;
 			tables: typeof tables;
+			relations: typeof relations;
 	}
 }
 export default schema
@@ -377,15 +330,3 @@ export default schema
  */
 export const templateHead = (slug) => dedent `
   /** ${slug} ============================================== **/`;
-export const templateDirectories = (slug) => `
-export const ${withDirectoriesSuffix(slug)} = sqliteTable('${s(withDirectoriesSuffix(slug))}', {
-  id: text('id').notNull().primaryKey(),
-  parent: text('parent').references(():any => ${withDirectoriesSuffix(slug)}.id, {
-		onDelete : 'cascade',
-		onUpdate : 'cascade',
-	}),
-  name: text('name').notNull(),
-  createdAt: integer('created_at', { mode: 'timestamp_ms' }),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
-})
-`;

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

@@ -1,7 +1,7 @@
-import cache from '../../core/dev/cache/index.server.js';
+import cache from '../../core/dev/cache.server.js';
 import { getPackageManager } from '../../core/dev/cli/util/package-manager.server.js';
-import { schemaPath } from '../../core/dev/constants.js';
-import { logger } from '../../core/logger/index.server.js';
+import { schemaPath } from '../../core/dev/constants.server.js';
+import { logger } from '../../core/logger.server.js';
 import fs from 'fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
@@ -11,8 +11,7 @@ const write = (schema) => {
     // RIME_CONFIG_DIR change can leave the schema content byte-identical while the file it needs
     // to land at moves, and drizzle-kit still needs to re-run against the new location.
     const cacheValue = `${outputFile}\n${schema}`;
-    const cachedSchema = cache.get('schema');
-    if (cachedSchema && cachedSchema === cacheValue) {
+    if (cache.matches('schema', cacheValue)) {
         return;
     }
     const outputDir = path.dirname(outputFile);
@@ -35,6 +34,20 @@ const write = (schema) => {
     };
     const command = commandMap[pm];
     logger.info(`[✓] Schema: generated at ${outputFile}`);
+    // Drizzle 1.0 restructured the migrations folder: `meta/_journal.json` is gone and each
+    // migration's snapshot moved beside its SQL. Kit refuses to read the old shape at all, so an
+    // app whose `db/` predates the upgrade cannot generate or migrate until it is converted.
+    //
+    // Converted here rather than left to the app, because rime is what runs kit — the alternative
+    // is a first `rime dev` after upgrading that fails on a message about a command the app never
+    // calls itself. Said out loud, because it rewrites files git is tracking.
+    if (fs.existsSync(path.resolve(process.cwd(), 'db', 'meta', '_journal.json'))) {
+        logger.info('Migrations folder predates drizzle 1.0 — converting with `drizzle-kit up`.');
+        const upResult = spawnSync(command, ['drizzle-kit', 'up'], { stdio: 'inherit' });
+        if (upResult.error || upResult.status !== 0) {
+            throw new Error('drizzle-kit up failed — the migrations folder could not be converted');
+        }
+    }
     console.log(`\n ⚡︎ ${command} drizzle-kit generate \n`);
     const generateResult = spawnSync(command, ['drizzle-kit', 'generate'], { stdio: 'inherit' });
     if (generateResult.error || generateResult.status !== 0) {
@@ -49,6 +62,6 @@ const write = (schema) => {
     // Only mark the schema as in sync once generate + migrate both actually
     // succeeded — otherwise a future run with an unchanged schema string would
     // skip re-running drizzle-kit and the DB would stay silently out of sync.
-    cache.set('schema', cacheValue);
+    cache.remember('schema', cacheValue);
 };
 export default write;

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

@@ -1,38 +1,32 @@
+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 type { Dic } from '../util/types.js';
 import { LibSQLDatabase } from 'drizzle-orm/libsql';
-import createAreaFacade from './area.server.js';
-import createAuthFacade from './auth.server.js';
-import createBlocksFacade from './blocks.server.js';
-import createCollectionFacade from './collection.server.js';
 import generateSchema from './generate-schema/index.server.js';
-import type { RelationFieldsMap } from './generate-schema/relations/definition.server.js';
-import createRelationsFacade from './relations.server.js';
-import { transformerFacade } from './transform.server.js';
-import createTreeFacade from './tree.server.js';
+import type { RelationFieldsMap } from './generate-schema/root.server.js';
 import type { GenericTable } from './types.server.js';
-import { updateDocumentUrl } from './url.server.js';
-import { updateTableRecord } from './util.server.js';
 type Schema = GetRegisterType<'Schema'>;
 export declare function adapterSqlite(database: string): {
-    createAdapter: <C extends Config>(configCtx: ConfigContext<C>) => Promise<Adapter>;
+    createAdapter: <C extends Config>(configCtx: ConfigContext<C>) => Promise<SqliteAdapter>;
     generateSchema: typeof generateSchema;
 };
-export type Adapter = {
-    collection: ReturnType<typeof createCollectionFacade>;
-    area: ReturnType<typeof createAreaFacade>;
-    blocks: ReturnType<typeof createBlocksFacade>;
-    tree: ReturnType<typeof createTreeFacade>;
-    relations: ReturnType<typeof createRelationsFacade>;
-    transform: ReturnType<typeof transformerFacade>;
-    auth: ReturnType<typeof createAuthFacade>;
-    db: LibSQLDatabase<Schema>;
+/**
+ * Everything this adapter offers: the `Adapter` contract core programs against, plus the
+ * SQL-specific escape hatch it exposes on top.
+ *
+ * The split is the point. `Adapter` lives in core and is written in core's vocabulary; the
+ * members below are things only a SQL adapter can honour, and no core code may use them —
+ * `rime.adapter.db` is documented for *consumers* who need to drop to drizzle.
+ *
+ * `createAdapter`'s return type is checked against `Adapter` where it is declared, so a facade
+ * that drifts from the contract is a build error rather than a runtime surprise.
+ */
+export type SqliteAdapter = Adapter & {
+    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
     tables: GetRegisterType<'Tables'>;
     getTable<T>(key: string): T extends any ? GenericTable : T;
-    updateRecord(id: string, tableName: string, data: Dic): Awaited<ReturnType<typeof updateTableRecord>>;
-    updateDocumentUrl: (url: string, params: Omit<Parameters<typeof updateDocumentUrl>[1], 'db' | 'tables'>) => Promise<void>;
+    tableForSlug<T>(slug: string): T extends any ? GenericTable : T;
     readonly schema: Schema;
     readonly relationFieldsMap: RelationFieldsMap;
 };

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

@@ -1,15 +1,14 @@
 import { drizzle, LibSQLDatabase } from 'drizzle-orm/libsql';
 import path from 'path';
-import createAreaFacade from './area.server.js';
-import createAuthFacade from './auth.server.js';
-import createBlocksFacade from './blocks.server.js';
-import createCollectionFacade from './collection.server.js';
+import createAuthHandle from './auth.server.js';
+import createBlocksHandle from './blocks.server.js';
 import generateSchema from './generate-schema/index.server.js';
-import createRelationsFacade from './relations.server.js';
-import { transformerFacade } from './transform.server.js';
-import createTreeFacade from './tree.server.js';
-import { updateDocumentUrl } from './url.server.js';
-import { updateTableRecord } from './util.server.js';
+import { baseTableName } from './naming.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) {
     //
     return {
@@ -21,32 +20,31 @@ const createAdapter = async (args) => {
     const { database, configCtx } = args;
     const schema = (await import('$rime/schema'));
     const dbPath = path.join(process.cwd(), 'db', database);
-    const db = drizzle('file:' + dbPath, { schema: schema.default });
+    // `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 tables = schema.tables;
-    const blocks = createBlocksFacade({ db, tables });
-    const tree = createTreeFacade({ db, tables });
-    const relations = createRelationsFacade({ db, tables });
-    const auth = createAuthFacade({
+    // Two words, and each is the contract's own. `core/adapter.ts` declares `BlocksHandle`,
+    // `TreeHandle`, `RelationsHandle`, `TransformHandle` and `AuthHandle` — one object of verbs
+    // each — and `PrototypeHandle` / `TableHandle`, which are looked up by slug. The factories are
+    // named for what they build, so a name here can be checked against a type there. It was three
+    // words for the same idea: Facade, Registry and Handles.
+    const blocks = createBlocksHandle({ db, tables });
+    const tree = createTreeHandle({ db, tables });
+    const relations = createRelationsHandle({ db, tables });
+    const auth = createAuthHandle({
         db,
         schema: schema.default
     });
-    const collection = createCollectionFacade({
-        db,
-        tables,
-        configCtx
-    });
-    const area = createAreaFacade({
-        db,
-        tables,
-        configCtx
-    });
-    const transform = transformerFacade({
+    const prototypes = createPrototypeRegistry({ db, tables, configCtx });
+    const table = createTableHandles({ db, tables });
+    const transform = createTransformHandle({
         tables,
         configCtx
     });
     return {
-        collection,
-        area,
+        ...prototypes,
+        table,
         blocks,
         tree,
         relations,
@@ -57,15 +55,14 @@ const createAdapter = async (args) => {
         getTable(key) {
             return tables[key];
         },
-        async updateRecord(id, tableName, data) {
-            return await updateTableRecord(db, tables, tableName, { recordId: id, data });
-        },
-        async updateDocumentUrl(url, params) {
-            return await updateDocumentUrl(url, {
-                ...params,
-                db,
-                tables
-            });
+        /**
+         * The table holding a *prototype's* rows, by slug.
+         *
+         * Part of the escape hatch, not of the Adapter contract: core asks for documents by slug
+         * and never for the table they sit in.
+         */
+        tableForSlug(slug) {
+            return tables[baseTableName(slug)];
         },
         get schema() {
             return schema.default;

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

@@ -0,0 +1,31 @@
+import type { ConfigContext } from '../core/rime.server.js';
+import type { Dic } from '../util/types.js';
+/**
+ * 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 declare const localeOrder: (configCtx: ConfigContext, locale?: string, fallback?: boolean) => string[] | undefined;
+/**
+ * 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 declare const mergeLocaleRows: (rows: Dic[] | undefined, order: string[]) => Dic;