rimecms 0.33.0 → 1.0.0

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

@@ -1,5 +1,5 @@
 import type { GetRegisterType } from '../index.js';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { SqliteDatabase } from './types.server.js';
 /**
  * All that is left of the auth facade: Better-auth's own database adapter.
  *
@@ -11,7 +11,7 @@ import type { LibSQLDatabase } from 'drizzle-orm/libsql';
  * because those are declared tables rather than a hand-written template.
  */
 declare const createAuthHandle: (args: {
-    db: LibSQLDatabase<GetRegisterType<"Relations">>;
+    db: SqliteDatabase;
     schema: GetRegisterType<"Schema">;
 }) => {
     betterAuthAdapter: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;

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

@@ -3,7 +3,7 @@ import { omit, pick } from '../util/object.js';
 import { randomId } from '../util/random.js';
 import { baseFieldNames } from '../core/fields/util.js';
 import { and, eq, getTableColumns } from 'drizzle-orm';
-import { JOIN_SUFFIX } from './naming.server.js';
+import { isPathsTable, JOIN_SUFFIX } from './naming.server.js';
 /**
  * Main function to generated primaryKeys
  */
@@ -121,7 +121,7 @@ export function mergeContentRow(doc, contentTable, config, select) {
         const rootProps = ['createdAt', 'id', ...baseFieldNames(config)];
         const hasRootSelectColumn = rootProps.some((column) => select.includes(column));
         // A resolved reference's target, joined only when its column was selected.
-        const joined = Object.keys(doc).filter((key) => key.endsWith(JOIN_SUFFIX));
+        const joined = Object.keys(doc).filter((key) => key.endsWith(JOIN_SUFFIX) || isPathsTable(key));
         // Pick the selected base columns on doc, or only the "id"
         const docFields = hasRootSelectColumn
             ? pick([...select.filter((field) => rootProps.includes(field)), 'id', ...joined], doc)

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

@@ -0,0 +1,12 @@
+import type { SqliteDatabase } from './types.server.js';
+export type SqliteDriver = 'libsql' | 'bun';
+/**
+ * Opens the database with the configured driver.
+ *
+ * Each driver is imported only when chosen, so a Node process never loads `bun:sqlite`.
+ */
+export declare function connect(args: {
+    driver: SqliteDriver;
+    dbPath: string;
+    relations: any;
+}): Promise<SqliteDatabase>;

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

@@ -0,0 +1,31 @@
+import { building } from '$app/environment';
+import { logger } from '../core/logger.server.js';
+/**
+ * Opens the database with the configured driver.
+ *
+ * Each driver is imported only when chosen, so a Node process never loads `bun:sqlite`.
+ */
+export async function connect(args) {
+    const { dbPath, relations } = args;
+    let driver = args.driver;
+    if (driver === 'bun' && !process.versions.bun) {
+        // `rime generate`/`init` (bin runs on Node) and `vite build` only need a connection to
+        // boot, not a fast one — libsql opens the same file.
+        if (!building && !process.env.RIME_CLI) {
+            throw new Error("adapterSqlite driver 'bun' needs the Bun runtime — run with `bun --bun vite dev` / `bun index.js`");
+        }
+        logger.debug("driver 'bun' outside Bun, falling back to libsql");
+        driver = 'libsql';
+    }
+    // `relations` comes untyped from the generated schema module; the casts restore `Relations`.
+    if (driver === 'bun') {
+        const { drizzle } = await import('drizzle-orm/bun-sqlite');
+        const db = drizzle(dbPath, { relations });
+        // bun:sqlite opens a database with foreign keys off, libsql with them on. Every cascade and
+        // set-null of the schema depends on them.
+        db.$client.run('PRAGMA foreign_keys = ON');
+        return db;
+    }
+    const { drizzle } = await import('drizzle-orm/libsql');
+    return drizzle('file:' + dbPath, { relations });
+}

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

@@ -1,9 +1,9 @@
 import { authColumns } from '../../core/auth/tables.js';
-import { baseTableName, declaredTableProperty } from '../naming.server.js';
+import { baseTableName, declaredTableProperty, tableName } from '../naming.server.js';
 import { date } from '../../fields/date/index.js';
 import { generateJunctionTableDefinition } from './relations/junction.server.js';
 import buildRootTable, {} from './root.server.js';
-import { templateDeclaredTable, templateExportRelationsFieldsToTable, templateExportSchema, templateExportTables, templateHead, templateImports, templateRelations } from './templates.server.js';
+import { templateDeclaredTable, templateExportRelationsFieldsToTable, templateExportSchema, templateExportTables, templateHead, templateImports, templatePathsTable, templateRelations } from './templates.server.js';
 import write from './write.server.js';
 export async function generateSchemaString(config) {
     // Every prototype config in the build, each paired with the features that extend its kind —
@@ -43,7 +43,7 @@ export async function generateSchemaString(config) {
                 fields: [
                     ...prototype.fields.filter((field) => field.get.root),
                     date('createdAt').hidden(),
-                    date('updatedAt').hidden()
+                    date('updatedAt').hidden().$index()
                 ],
                 rootName: baseName,
                 locales: [],
@@ -87,6 +87,14 @@ export async function generateSchemaString(config) {
             [rootTableName]: relationFieldsMap
         };
         schema.push(prototypeSchema, junctionTable);
+        // A collection with `$url` keeps its pages' addresses in a table of their own, off the base
+        // table: an address belongs to the page, not to one of its versions.
+        if (prototype.type === 'collection' && prototype.$url) {
+            const pathsTable = tableName({ owner: baseName, child: { kind: 'paths' } });
+            schema.push(templatePathsTable(baseName));
+            enumTables = [...enumTables, pathsTable];
+            (relationTree[baseName] ??= []).push(pathsTable);
+        }
     }
     // Tables no prototype declares — better-auth's own, plus whatever a plugin added during the
     // configure phase. Nothing here knows who asked for one.

package/dist/adapter-sqlite/generate-schema/root.server.d.ts

@@ -1,5 +1,5 @@
 import type { LocaleConfig } from '../../core/locale/types.js';
-import { type FieldBuilder } from '../../core/fields/builders/field-builder.js';
+import type { FieldBuilder } from '../../core/fields/builders/field-builder.js';
 import type { Field } from '../../fields/types.js';
 import type { TableName } from '../naming.server.js';
 import type { ColumnDeclaration } from '../../core/adapter.js';
@@ -45,9 +45,18 @@ type Return = {
     referenceJoins: ReferenceJoin[];
 };
 /**
- * This function generates the root table schema for collection/areas, including its localized version if needed,
- * and also generates tables for blocks and tree fields.
- * It also keeps track of relation fields and their localization status to properly generate relations later on.
+ * The table of a collection or area, its locales branch when a field is localized, and one child
+ * table per block type and per tree field. Relation fields become no column; they are collected in
+ * `relationFieldsMap` for the junction table built later.
+ *
+ * The branches below decide where a field's rows are stored, not what is below it:
+ *
+ * ```
+ * relation                 junction rows      no column, an entry in relationFieldsMap
+ * a node with storage      a child table      blocks and tree, built by this function recursing
+ * a node without           the owner's row    group, tabs, and a container from a package
+ * leaf                     one column
+ * ```
  */
 declare const buildRootTable: ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap, relationsDic, featureColumns, versionsOf, blocksRegister }: Args) => Promise<Return>;
 export default buildRootTable;

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

@@ -1,23 +1,60 @@
-import {} from '../../core/fields/builders/field-builder.js';
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
-import { BlocksBuilder } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { walkFields } from '../../core/fields/walk.js';
 import { RelationFieldBuilder } from '../../fields/relation/index.js';
-import { TabsBuilder } from '../../fields/tabs/index.js';
-import { TreeBuilder } from '../../fields/tree/index.js';
 import { tableName as buildTableName, getSchemaColumnNames } from '../naming.server.js';
 import { toSchemaColumn } from './column.server.js';
 import { templateDeclaredColumn, templateLocale, templateParent, templateTable } from './templates.server.js';
+/** A container flattened into the owner's row: its name and the column's, joined. */
+const joinColumn = (parent, part) => (parent ? `${parent}__${part}` : part);
 /**
- * This function generates the root table schema for collection/areas, including its localized version if needed,
- * and also generates tables for blocks and tree fields.
- * It also keeps track of relation fields and their localization status to properly generate relations later on.
+ * The table of a collection or area, its locales branch when a field is localized, and one child
+ * table per block type and per tree field. Relation fields become no column; they are collected in
+ * `relationFieldsMap` for the junction table built later.
+ *
+ * The branches below decide where a field's rows are stored, not what is below it:
+ *
+ * ```
+ * relation                 junction rows      no column, an entry in relationFieldsMap
+ * a node with storage      a child table      blocks and tree, built by this function recursing
+ * a node without           the owner's row    group, tabs, and a container from a package
+ * leaf                     one column
+ * ```
  */
 const buildRootTable = async ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap = {}, relationsDic = {}, featureColumns = [], versionsOf, blocksRegister }) => {
     const blocksTables = [];
     const referenceJoins = [];
     let relationFieldsHasLocale = false;
-    const generateFieldsTemplates = async (fields, withLocalized, parentPath = '') => {
+    /**
+     * One child table under the root for a branch stored as rows of its own, built by recursing.
+     * Registered once: two blocks fields declaring the same type share the type's table.
+     */
+    const childTable = async (storage, fields) => {
+        const name = buildTableName({ owner: rootName, child: storage });
+        if (blocksRegister.includes(name))
+            return;
+        relationsDic = { ...relationsDic, [rootName]: [...(relationsDic[rootName] || []), name] };
+        const nested = await buildRootTable({
+            blocksRegister,
+            fields,
+            tableName: name,
+            hasParent: true,
+            relationsDic,
+            relationFieldsMap,
+            locales,
+            rootName
+        });
+        relationsDic = nested.relationsDic;
+        relationFieldsMap = nested.relationFieldsMap;
+        if (nested.relationFieldsHasLocale)
+            relationFieldsHasLocale = true;
+        referenceJoins.push(...nested.referenceJoins);
+        blocksRegister.push(name);
+        blocksTables.push(nested.schema);
+    };
+    /**
+     * The columns of one table, and in `indexed` the ones a field asked `$index()` for.
+     */
+    const generateFieldsTemplates = async (fields, withLocalized, parentPath = '', indexed = []) => {
         let templates = [];
         const checkLocalized = (field) => {
             return ((withLocalized && field.get.localized) ||
@@ -25,19 +62,8 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                 withLocalized === undefined);
         };
         for (const field of fields) {
-            if (field instanceof GroupFieldBuilder) {
-                const groupPath = parentPath ? `${parentPath}__${field.name}` : field.name;
-                const groupFields = await generateFieldsTemplates(field.get.fields, withLocalized, groupPath);
-                templates = [...templates, ...groupFields];
-            }
-            else if (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    const tabPath = parentPath ? `${parentPath}__${tab.name}` : tab.name;
-                    const tabFields = await generateFieldsTemplates(tab.get.fields, withLocalized, tabPath);
-                    templates = [...templates, ...tabFields];
-                }
-            }
-            else if (field instanceof RelationFieldBuilder) {
+            // Junction rows: no column here, and the relations table wants to know it exists.
+            if (field instanceof RelationFieldBuilder) {
                 if (field.get.localized) {
                     relationFieldsHasLocale = true;
                 }
@@ -49,72 +75,28 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                     }
                 };
             }
-            else if (field instanceof BlocksBuilder) {
-                for (const block of field.get.blocks) {
-                    const blockTableName = buildTableName({
-                        owner: rootName,
-                        child: { kind: 'blocks', name: block.name }
-                    });
-                    if (!blocksRegister.includes(blockTableName)) {
-                        // Add the blocks as a relation of the root collection
-                        relationsDic = {
-                            ...relationsDic,
-                            [rootName]: [...(relationsDic[rootName] || []), blockTableName]
-                        };
-                        // Build the child blocks table
-                        const { schema: blockTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale, referenceJoins: nestedReferenceJoins } = await buildRootTable({
-                            blocksRegister,
-                            fields: block.get.fields,
-                            tableName: blockTableName,
-                            hasParent: true,
-                            relationsDic,
-                            relationFieldsMap,
-                            locales,
-                            rootName
-                        });
-                        relationsDic = nestedRelationsDic;
-                        relationFieldsMap = nestedRelationFieldsDic;
-                        if (nestedRelationFieldsHasLocale)
-                            relationFieldsHasLocale = true;
-                        referenceJoins.push(...nestedReferenceJoins);
-                        blocksRegister.push(blockTableName);
-                        blocksTables.push(blockTable);
+            else if (field.use.nodes().length) {
+                // A branch stored as rows of its own gets a child table; any other flattens into the
+                // owner's row, `attributes__seo__title`.
+                for (const node of field.use.nodes()) {
+                    if (node.storage) {
+                        await childTable(node.storage, node.fields);
+                        continue;
                     }
-                }
-            }
-            else if (field instanceof TreeBuilder) {
-                const treeTableName = buildTableName({
-                    owner: rootName,
-                    child: { kind: 'tree', name: field.name }
-                });
-                if (!blocksRegister.includes(treeTableName)) {
-                    // Add the tree table as relation of the root collection
-                    relationsDic = {
-                        ...relationsDic,
-                        [rootName]: [...(relationsDic[rootName] || []), treeTableName]
-                    };
-                    const { schema: treeTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale, referenceJoins: nestedReferenceJoins } = await buildRootTable({
-                        blocksRegister,
-                        fields: field.get.fields,
-                        tableName: treeTableName,
-                        hasParent: true,
-                        relationsDic,
-                        relationFieldsMap,
-                        locales,
-                        rootName
-                    });
-                    relationsDic = nestedRelationsDic;
-                    relationFieldsMap = nestedRelationFieldsDic;
-                    if (nestedRelationFieldsHasLocale)
-                        relationFieldsHasLocale = true;
-                    referenceJoins.push(...nestedReferenceJoins);
-                    blocksRegister.push(treeTableName);
-                    blocksTables.push(treeTable);
+                    const own = field.name ? joinColumn(parentPath, field.name) : parentPath;
+                    const prefix = node.segment ? joinColumn(own, node.segment) : own;
+                    templates = [
+                        ...templates,
+                        ...(await generateFieldsTemplates(node.fields, withLocalized, prefix, indexed))
+                    ];
                 }
             }
             else if (field instanceof FormFieldBuilder) {
                 if (checkLocalized(field)) {
                     templates.push(toSchemaColumn(field, parentPath) + ',');
+                    if (field.get.index) {
+                        indexed.push(getSchemaColumnNames({ name: field.name, parentPath }).camel);
+                    }
                     // A reference the read resolves gets a relation to its target beside the column.
                     if (field._references?.resolve) {
                         referenceJoins.push({
@@ -128,12 +110,15 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         }
         return templates;
     };
+    // A child row is read by its owner. A field's `$index()` adds its own column below.
+    const indexed = hasParent || versionsOf ? ['ownerId'] : [];
     let table;
     if (locales && locales.length && hasLocalizedField(incomingFields)) {
         const tableNameLocales = buildTableName({ owner: tableName, branch: 'locales' });
-        const strLocalizedFields = await generateFieldsTemplates(incomingFields, true);
+        const localizedIndexed = [];
+        const strLocalizedFields = await generateFieldsTemplates(incomingFields, true, '', localizedIndexed);
         relationsDic[tableName] = [...(relationsDic[tableName] || []), tableNameLocales];
-        const strUnlocalizedFields = await generateFieldsTemplates(incomingFields, false);
+        const strUnlocalizedFields = await generateFieldsTemplates(incomingFields, false, '', indexed);
         if (hasParent) {
             strUnlocalizedFields.push(templateParent(rootName));
         }
@@ -143,11 +128,11 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         for (const column of featureColumns) {
             strUnlocalizedFields.push(templateDeclaredColumn(column) + ',');
         }
-        table = templateTable(tableName, strUnlocalizedFields.join('\n  '));
-        table += templateTable(tableNameLocales, [...strLocalizedFields, templateLocale(), templateParent(tableName)].join('\n  '));
+        table = templateTable(tableName, strUnlocalizedFields.join('\n  '), indexed);
+        table += templateTable(tableNameLocales, [...strLocalizedFields, templateLocale(), templateParent(tableName)].join('\n  '), ['ownerId', ...localizedIndexed]);
     }
     else {
-        const strFields = await generateFieldsTemplates(incomingFields);
+        const strFields = await generateFieldsTemplates(incomingFields, undefined, '', indexed);
         if (hasParent) {
             strFields.push(templateParent(rootName));
         }
@@ -157,7 +142,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         for (const column of featureColumns) {
             strFields.push(templateDeclaredColumn(column) + ',');
         }
-        table = templateTable(tableName, strFields.join('\n  '));
+        table = templateTable(tableName, strFields.join('\n  '), indexed);
     }
     return {
         schema: [table, ...blocksTables].join('\n\n'),
@@ -167,47 +152,6 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         referenceJoins
     };
 };
-function hasLocalizedField(fields) {
-    // Iterate through each field in the array
-    for (const field of fields) {
-        // Case 1: If it's a group field, check all fields within the group
-        if (field instanceof GroupFieldBuilder) {
-            if (hasLocalizedField(field.get.fields)) {
-                return true;
-            }
-        }
-        // Case 2: If it's a tabs field, check all fields within each tab
-        else if (field instanceof TabsBuilder) {
-            for (const tab of field.get.tabs) {
-                if (hasLocalizedField(tab.get.fields)) {
-                    return true;
-                }
-            }
-        }
-        // Case 3: If it's a blocks field, check all fields within each block
-        else if (field instanceof BlocksBuilder) {
-            if (field.get.localized)
-                return true;
-            for (const block of field.get.blocks) {
-                if (hasLocalizedField(block.get.fields)) {
-                    return true;
-                }
-            }
-        }
-        // Case 3: If it's a tree field, check all fields
-        else if (field instanceof TreeBuilder) {
-            if (field.get.localized)
-                return true;
-            if (hasLocalizedField(field.get.fields)) {
-                return true;
-            }
-        }
-        // Case 4: For regular form fields, check if it's marked as localized
-        else if (field instanceof FormFieldBuilder && field.get.localized) {
-            return true;
-        }
-    }
-    // If no localized fields were found, return false
-    return false;
-}
+/** Whether anything in the tree is localized, container fields included. */
+const hasLocalizedField = (fields) => [...walkFields(fields)].some((visit) => visit.field.get.localized);
 export default buildRootTable;

package/dist/adapter-sqlite/generate-schema/templates.server.d.ts

@@ -1,13 +1,14 @@
 import type { FieldReference } from '../../core/fields/builders/form-field-builder.js';
 import type { ColumnDeclaration, TableDeclaration } from '../../core/adapter.js';
+import { type TableName } from '../naming.server.js';
 /**
  * Generates the standard imports needed for Drizzle ORM schema definitions
  * Includes SQLite table definitions, relations, and a primary key helper function
  */
-export declare const templateImports = "\nimport { text, integer, sqliteTable, real } from \"drizzle-orm/sqlite-core\";\nimport { defineRelations } from 'drizzle-orm';\n\nconst pk = () => text(\"id\").primaryKey().$defaultFn(() => crypto.randomUUID());\n";
+export declare const templateImports = "\nimport { text, integer, sqliteTable, real, index, unique, check, foreignKey } from \"drizzle-orm/sqlite-core\";\nimport { defineRelations, sql } from 'drizzle-orm';\n\nconst pk = () => text(\"id\").primaryKey().$defaultFn(() => crypto.randomUUID());\n";
 /**
  * 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
@@ -15,10 +16,19 @@ export declare const templateImports = "\nimport { text, integer, sqliteTable, r
  *   id: pk(),
  *   title: text('title'),
  *   content: text('content')
- * })
+ * }, (t) => [index('pages_updated_at_idx').on(t.updatedAt)])
  * ```
  */
-export declare const templateTable: (table: string, content: string) => string;
+export declare const templateTable: (table: string, content: string, indexed?: string[]) => string;
+/**
+ * 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 declare const templateIndexes: (table: string, columns: string[]) => string;
 /**
  * Generates a locale field for internationalized tables
  *
@@ -90,6 +100,17 @@ export declare const templateUniqueRequired: (field: {
     unique?: boolean;
     required?: boolean;
 }, defaultValue?: string | number | boolean | object | unknown[]) => string;
+/**
+ * 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 declare const templatePathsTable: (owner: TableName) => string;
 /** Template rows Relation */
 /**
  * The whole schema's relations, in one declaration.
@@ -142,7 +163,7 @@ export declare const templateRelations: (tree: Record<string, string[]>, referen
 export declare const templateFieldRelationColumn: (slug: string) => string;
 /**
  * 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
@@ -154,7 +175,7 @@ export declare const templateFieldRelationColumn: (slug: string) => string;
  *   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 declare const templateRelationFieldsTable: ({ table, junctionTable, relations, hasLocale }: FieldsRelationTableArgs) => string;

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

@@ -1,5 +1,5 @@
 import { toSnakeCase } from '../../util/string.js';
-import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName } from '../naming.server.js';
+import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName, tableName } from '../naming.server.js';
 import dedent from 'dedent';
 const s = toSnakeCase;
 /**
@@ -7,14 +7,14 @@ const s = toSnakeCase;
  * 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,6 +171,37 @@ 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.
@@ -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 {};