rimecms 0.28.10 → 0.30.0

package/README.md

@@ -93,7 +93,7 @@ export default defineConfig({
 ```typescript
 // src/hooks.server.ts (should be created)
 import config from '$lib/+rime.generated/rime.config.server.js';
-import { handlers } from 'rimecms';
+import { handlers } from 'rimecms/server';
 import { sequence } from '@sveltejs/kit/hooks';
 
 export const handle = sequence(...(await handlers(config)));
@@ -131,7 +131,7 @@ curl -v POST http://localhost:5173/api/init \
 ```typescript
 // ./src/lib/+rime/rime.config.ts
 import { rime, Collection, Area } from '$rime/config';
-import { adapterSqlite } from 'rimecms/sqlite';
+import { adapterSqlite } from 'rimecms/adapter-sqlite';
 import { Settings2 } from '@lucide/svelte';
 import { relation, link, richText, text, toggle } from 'rimecms/fields';
 import { access } from "rimecms/util";
@@ -261,10 +261,10 @@ It's doing bascically `vite build` under the hood and create the polka server fi
 - [x] more better-auth integration
 - [x] Handle relation poperties in queries
 - [~] Documentation
+- [ ] Live Edit system in practice
 - [ ] configurable files storage adapter (local, s3, etc)
 - [ ] other storage adapter (postgress, turso, etc)
 - [ ] auto-saved draft
-- [ ] Live Edit system in practice
 - [ ] Put bin commands in a separate package ex: @rime/kit
 
 ## Acknowledgments

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

@@ -23,18 +23,20 @@ const createAreaFacade = (args) => {
         if (!areaConfig) {
             throw new RimeError(RimeError.INIT, slug + ' is not an area, should never happen');
         }
+        // `db.query[slug]` can't be typed precisely: with a single registered area,
+        // AreaSlug collapses to one string literal and Drizzle infers an overly
+        // precise (and here incorrect) per-table shape instead of the general one.
+        const queryTable = db.query[slug];
         const hasVersions = !!areaConfig.versions;
         if (!hasVersions) {
             const params = {
                 columns: adapterUtil.columnsParams({ table: tables[slug], select }),
                 with: buildWithParam({ slug, select, locale, tables, config: areaConfig }) || undefined
             };
-            // @ts-expect-error slug is a tableName
-            let doc = await db.query[slug].findFirst(params);
+            let doc = await queryTable.findFirst(params);
             if (!doc) {
                 await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
-                // @ts-expect-error slug is a tableName
-                doc = await db.query[slug].findFirst(params);
+                doc = await queryTable.findFirst(params);
             }
             if (!doc) {
                 throw new Error('Database error');
@@ -43,8 +45,7 @@ const createAreaFacade = (args) => {
         }
         else {
             // First check for record presence
-            // @ts-expect-error slug is a tableName
-            const area = await db.query[slug].findFirst({ id: true });
+            const area = await queryTable.findFirst({ id: true });
             // If no area exists yet, create it
             if (!area) {
                 await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
@@ -98,8 +99,7 @@ const createAreaFacade = (args) => {
                     }
                 };
             }
-            // @ts-expect-error slug is a tableName
-            const doc = await db.query[slug].findFirst(params);
+            const doc = await queryTable.findFirst(params);
             if (!doc) {
                 throw new RimeError(RimeError.OPERATION_ERROR);
             }

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

@@ -0,0 +1,13 @@
+import type { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import type { FormField } from '../../fields/types.js';
+/**
+ * Renders a single Drizzle column definition for any leaf FormFieldBuilder,
+ * driven by the field's own `dataType` (storage type) and `_references`
+ * (foreign key) — the adapter owns all Drizzle syntax, fields only declare
+ * storage semantics via `dataType`.
+ *
+ * @example
+ * // returns "title: text('title').notNull().default(\"\"),"
+ * toSchemaColumn(text('title').required())
+ */
+export declare function toSchemaColumn(field: FormFieldBuilder<FormField>, parentPath?: string): string;

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

@@ -0,0 +1,77 @@
+import { templateReferences, templateUniqueRequired } from './templates.server.js';
+import { getSchemaColumnNames } from './util.server.js';
+const COLUMN_EXPR = {
+    text: (snake) => `text('${snake}')`,
+    boolean: (snake) => `integer('${snake}', { mode: 'boolean' })`,
+    number: (snake) => `real('${snake}')`,
+    timestamp: (snake) => `integer('${snake}', { mode: 'timestamp_ms' })`,
+    json: (snake) => `text('${snake}', { mode: 'json' })`
+};
+// Single-call type guards for RESOLVE_DEFAULT below — calling
+// f.get.defaultValue itself has no reason to run twice per branch.
+// `ensureObject` intentionally matches `typeof v === 'object'` including
+// `null` (not `v !== null`), since that's what the pre-refactor per-field
+// toSchema checks did — a field with no explicit default (constructor sets
+// `defaultValue = null`) will keep `null`, not fall back to `{}`. Not
+// touching that here, even though it looks like a latent bug.
+const ensureString = (v) => (typeof v === 'string' ? v : undefined);
+const ensureNumber = (v) => (typeof v === 'number' ? v : undefined);
+const ensureBoolean = (v) => (typeof v === 'boolean' ? v : undefined);
+const ensureDate = (v) => (v instanceof Date ? v : undefined);
+const ensureObject = (v) => typeof v === 'object' ? v : undefined;
+/**
+ * Resolves the `.default(...)` fallback used when a field is required but has
+ * no usable value in `field.defaultValue` — SQLite needs a type-correct
+ * DEFAULT to add a NOT NULL column via drizzle-kit migration on a table with
+ * existing rows. Keyed by field type (not dataType) and reading
+ * `field.get.defaultValue` directly, exactly mirroring what each field's own
+ * `toSchema` did before this refactor — kept here, not on the field builders,
+ * since it's schema-generation-only and not part of a field's public API.
+ */
+const RESOLVE_DEFAULT = {
+    text: (f) => ensureString(f.get.defaultValue) ?? '',
+    email: (f) => ensureString(f.get.defaultValue) ?? '',
+    slug: (f) => ensureString(f.get.defaultValue) ?? '',
+    combobox: (f) => ensureString(f.get.defaultValue) ?? '',
+    radio: (f) => ensureString(f.get.defaultValue) ?? '',
+    textarea: (f) => ensureString(f.get.defaultValue) ?? '',
+    time: (f) => ensureString(f.get.defaultValue) ?? '00:00',
+    checkbox: (f) => f.get.defaultValue ?? false,
+    toggle: (f) => ensureBoolean(f.get.defaultValue) ?? false,
+    number: (f) => ensureNumber(f.get.defaultValue) ?? 0,
+    date: (f) => ensureDate(f.get.defaultValue)?.getTime() ?? 0,
+    link: (f) => ensureObject(f.get.defaultValue) ?? {},
+    richText: (f) => ensureObject(f.get.defaultValue) ?? {},
+    relation: () => ({}),
+    select: (f) => {
+        const many = f.get.many;
+        const empty = many ? [] : '';
+        const value = f.get.defaultValue;
+        return typeof value === 'undefined' ? empty : value;
+    }
+};
+/**
+ * Renders a single Drizzle column definition for any leaf FormFieldBuilder,
+ * driven by the field's own `dataType` (storage type) and `_references`
+ * (foreign key) — the adapter owns all Drizzle syntax, fields only declare
+ * storage semantics via `dataType`.
+ *
+ * @example
+ * // returns "title: text('title').notNull().default(\"\"),"
+ * toSchemaColumn(text('title').required())
+ */
+export function toSchemaColumn(field, parentPath) {
+    const { camel, snake } = getSchemaColumnNames({ name: field.name, parentPath });
+    // `unique` only exists on the field types that support it (text/email/slug);
+    // reading it off the generic FormField base needs a narrow cast, same as
+    // each field's own toSchema did today by typing against its concrete field.
+    const { unique, required } = field.get;
+    // `dataType` is implemented by every leaf field builder but isn't declared
+    // on the FormFieldBuilder base (see the comment there) — narrow cast here.
+    const dataType = field.dataType;
+    const columnExpr = COLUMN_EXPR[dataType](snake);
+    const referencesStr = field._references ? templateReferences(field._references) : '';
+    const defaultValue = RESOLVE_DEFAULT[field.type]?.(field);
+    const suffix = templateUniqueRequired({ unique, required }, defaultValue);
+    return `${camel}: ${columnExpr}${referencesStr}${suffix}`;
+}

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

@@ -1,7 +1,7 @@
 import { withVersionsSuffix } from '../../core/naming.js';
 import { date } from '../../fields/date/index.js';
-import { getFieldPrivateModule } from '../../fields/index.server.js';
 import { toCamelCase, toCamelCasePreserveTrailingUnderscoreSuffix, toPascalCase, toSnakeCase } from '../../util/string.js';
+import { toSchemaColumn } from './column.server.js';
 import { generateRelationshipDefinitions } from './relations/definition.server.js';
 import { generateJunctionTableDefinition } from './relations/junction.server.js';
 import buildRootTable from './root.server.js';
@@ -20,9 +20,6 @@ export async function generateSchemaString(config) {
         let rootTableName = collectionSlug;
         let versionsRelationsDefinitions = [];
         schema.push(templateHead(collectionSlug));
-        // utility function to filter out fields
-        const isRootField = (field) => '_root' in field.raw && field.raw._root;
-        const isNotRootField = (field) => !('_root' in field.raw) || !field.raw._root;
         if (collection.versions) {
             // Collection that have versions may need some fields forced on the root table and not root_versions
             // process the root table with these fields first then, handle versions related tables creation
@@ -30,7 +27,7 @@ export async function generateSchemaString(config) {
             // base root fields for versioned tables
             const baseRootFields = [date('createdAt').hidden(), date('updatedAt').hidden()];
             // Split fields that should be used on the root table
-            const rootFieldsFromConfig = [...collection.fields].filter(isRootField);
+            const rootFieldsFromConfig = [...collection.fields].filter((f) => f.get.root);
             const rootFields = [...rootFieldsFromConfig, ...baseRootFields];
             // Build the main root buildRootTable with only _root fields and created/updatedAt
             const { schema: rootCollectionSchema } = await buildRootTable({
@@ -72,7 +69,9 @@ export async function generateSchemaString(config) {
         }
         const { schema: collectionSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale } = await buildRootTable({
             blocksRegister,
-            fields: collection.versions ? collection.fields.filter(isNotRootField) : collection.fields,
+            fields: collection.versions
+                ? collection.fields.filter((f) => !f.get.root)
+                : collection.fields,
             rootName: rootTableName,
             locales: config.localization?.locales || [],
             hasAuth: !!collection.auth,
@@ -120,12 +119,8 @@ export async function generateSchemaString(config) {
             const manyVersionsToOneName = `rel_${rootTableName}HasOne${toPascalCase(areaSlug)}`;
             const oneToManyVersionsName = `rel_${areaSlug}HasMany${toPascalCase(rootTableName)}`;
             const baseRootFields = [date('createdAt').hidden(), date('updatedAt').hidden()];
-            async function fieldToSchema(field) {
-                const serverField = await getFieldPrivateModule(field);
-                return serverField && serverField.toSchema(field);
-            }
-            const schemaResults = await Promise.all(baseRootFields.map(fieldToSchema));
-            schema.push(templateTable(areaSlug, schemaResults.filter(Boolean).join(',\n')));
+            const schemaResults = baseRootFields.map((field) => toSchemaColumn(field));
+            schema.push(templateTable(areaSlug, schemaResults.join(',\n')));
             versionsRelationsDefinitions = [
                 templateRelationOne({
                     name: manyVersionsToOneName,

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

@@ -1,14 +1,13 @@
 import {} from '../../core/fields/builders/field-builder.js';
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
-import { isFormField } from '../../core/fields/util.js';
 import { withLocalesSuffix } from '../../core/naming.js';
-import { isBlocksField } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder, isGroupField } from '../../fields/group/index.js';
-import { getFieldPrivateModule } from '../../fields/index.server.js';
-import { isRelationField } from '../../fields/relation/index.js';
-import { isTabsField } from '../../fields/tabs/index.js';
+import { BlocksBuilder } from '../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../fields/relation/index.js';
+import { TabsBuilder } from '../../fields/tabs/index.js';
 import { TreeBuilder } from '../../fields/tree/index.js';
 import { toPascalCase } from '../../util/string.js';
+import { toSchemaColumn } from './column.server.js';
 import { templateHasAuth, templateLocale, templateParent, templateTable } from './templates.server.js';
 const p = toPascalCase;
 /**
@@ -22,38 +21,38 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
     const generateFieldsTemplates = async (fields, withLocalized, parentPath = '') => {
         let templates = [];
         const checkLocalized = (field) => {
-            return ((withLocalized && field.raw.localized) ||
-                (!withLocalized && !field.raw.localized) ||
+            return ((withLocalized && field.get.localized) ||
+                (!withLocalized && !field.get.localized) ||
                 withLocalized === undefined);
         };
         for (const field of fields) {
             if (field instanceof GroupFieldBuilder) {
                 const groupPath = parentPath ? `${parentPath}__${field.name}` : field.name;
-                const groupFields = await generateFieldsTemplates(field.raw.fields, withLocalized, groupPath);
+                const groupFields = await generateFieldsTemplates(field.get.fields, withLocalized, groupPath);
                 templates = [...templates, ...groupFields];
             }
-            else if (isTabsField(field.raw)) {
-                for (const tab of field.raw.tabs) {
-                    const tabPath = parentPath ? `${parentPath}__${tab.raw.name}` : tab.raw.name;
-                    const tabFields = await generateFieldsTemplates(tab.raw.fields, withLocalized, tabPath);
+            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 (isRelationField(field.raw)) {
-                if (field.raw.localized) {
+            else if (field instanceof RelationFieldBuilder) {
+                if (field.get.localized) {
                     relationFieldsHasLocale = true;
                 }
                 relationFieldsMap = {
                     ...relationFieldsMap,
-                    [field.raw.name]: {
-                        to: field.raw.relationTo,
-                        localized: field.raw.localized
+                    [field.name]: {
+                        to: field.get.relationTo,
+                        localized: field.get.localized
                     }
                 };
             }
-            else if (isBlocksField(field.raw)) {
-                for (const block of field.raw.blocks) {
-                    const blockTableName = `${rootName}Blocks${p(block.raw.name)}`;
+            else if (field instanceof BlocksBuilder) {
+                for (const block of field.get.blocks) {
+                    const blockTableName = `${rootName}Blocks${p(block.name)}`;
                     if (!blocksRegister.includes(blockTableName)) {
                         // Add the blocks as a relation of the root collection
                         relationsDic = {
@@ -63,7 +62,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                         // Build the child blocks table
                         const { schema: blockTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale } = await buildRootTable({
                             blocksRegister,
-                            fields: block.raw.fields,
+                            fields: block.get.fields,
                             tableName: blockTableName,
                             hasParent: true,
                             relationsDic,
@@ -90,7 +89,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                     };
                     const { schema: treeTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale } = await buildRootTable({
                         blocksRegister,
-                        fields: field.raw.fields,
+                        fields: field.get.fields,
                         tableName: treeTableName,
                         hasParent: true,
                         relationsDic,
@@ -108,10 +107,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
             }
             else if (field instanceof FormFieldBuilder) {
                 if (checkLocalized(field)) {
-                    const serverField = await getFieldPrivateModule(field);
-                    if (serverField) {
-                        templates.push(serverField.toSchema(field, parentPath) + ',');
-                    }
+                    templates.push(toSchemaColumn(field, parentPath) + ',');
                 }
             }
         }
@@ -159,39 +155,39 @@ 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 (isGroupField(field.raw)) {
-            if (hasLocalizedField(field.raw.fields)) {
+        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 (isTabsField(field.raw)) {
-            for (const tab of field.raw.tabs) {
-                if (hasLocalizedField(tab.raw.fields)) {
+        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 (isBlocksField(field.raw)) {
-            if (field.raw.localized)
+        else if (field instanceof BlocksBuilder) {
+            if (field.get.localized)
                 return true;
-            for (const block of field.raw.blocks) {
-                if (hasLocalizedField(block.raw.fields)) {
+            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.raw.localized)
+            if (field.get.localized)
                 return true;
-            if (hasLocalizedField(field.raw.fields)) {
+            if (hasLocalizedField(field.get.fields)) {
                 return true;
             }
         }
         // Case 4: For regular form fields, check if it's marked as localized
-        else if (isFormField(field.raw) && field.raw.localized) {
+        else if (field instanceof FormFieldBuilder && field.get.localized) {
             return true;
         }
     }

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

@@ -1,3 +1,4 @@
+import type { FieldReference } from '../../core/fields/builders/form-field-builder.js';
 /**
  * Generates the standard imports needed for Drizzle ORM schema definitions
  * Includes SQLite table definitions, relations, and a primary key helper function
@@ -36,6 +37,17 @@ export declare const templateLocale: () => string;
  * ```
  */
 export declare const templateParent: (parent: string) => string;
+/**
+ * Generates a `.references(...)` suffix for a field-level foreign key,
+ * used by column.server.ts's toSchemaColumn for fields configured via
+ * FormFieldBuilder#$references(...).
+ *
+ * @example
+ * ```typescript
+ * .references(() => staff.id, { onDelete: 'cascade' })
+ * ```
+ */
+export declare const templateReferences: ({ table, onDelete, onUpdate, selfReferencing }: FieldReference) => string;
 /**
  * Generates authentication-related fields for a table
  * Adds super admin flag for the panel users table

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

@@ -55,6 +55,25 @@ export const templateLocale = () => 'locale: text("locale"),';
 export const templateParent = (parent) => {
     return `ownerId: text("owner_id").references(() => ${parent}.id, { onDelete: 'cascade' }),`;
 };
+/**
+ * Generates a `.references(...)` suffix for a field-level foreign key,
+ * used by column.server.ts's toSchemaColumn for fields configured via
+ * FormFieldBuilder#$references(...).
+ *
+ * @example
+ * ```typescript
+ * .references(() => staff.id, { onDelete: 'cascade' })
+ * ```
+ */
+export const templateReferences = ({ table, onDelete, onUpdate, selfReferencing }) => {
+    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})`;
+};
 /**
  * Generates authentication-related fields for a table
  * Adds super admin flag for the panel users table

package/dist/adapter-sqlite/generate-schema/{util.d.ts → util.server.d.ts}

@@ -33,8 +33,8 @@ export declare const getBlocksTableNames: (slug: string, tables: Record<string,
  */
 export declare const makeBlockTableSlug: (slug: string, blockType: string) => string;
 /**
- * Generate the column's names for a given field name and its parent path
- * Snake case is used for sqlite column name and Camel case is user for the drizzle column property name
+ * Generate the column and property names for a field given its name and its parent path.
+ * Snake case is used for the sqlite column name and Camel case is used for the drizzle column property name.
  *
  * @example
  * // returns { camel : 'groupTitle', snake: 'group__title' }

package/dist/adapter-sqlite/generate-schema/{util.js → util.server.js}

@@ -34,8 +34,8 @@ export const getBlocksTableNames = (slug, tables) => Object.keys(tables).filter(
  */
 export const makeBlockTableSlug = (slug, blockType) => `${slug}Blocks${toPascalCase(blockType)}`;
 /**
- * Generate the column's names for a given field name and its parent path
- * Snake case is used for sqlite column name and Camel case is user for the drizzle column property name
+ * Generate the column and property names for a field given its name and its parent path.
+ * Snake case is used for the sqlite column name and Camel case is used for the drizzle column property name.
  *
  * @example
  * // returns { camel : 'groupTitle', snake: 'group__title' }

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

@@ -1,5 +1,5 @@
 import cache from '../../core/dev/cache/index.server.js';
-import { getPackageManager } from '../../core/dev/cli/init/package-manager-util.server.js';
+import { getPackageManager } from '../../core/dev/cli/util/package-manager.server.js';
 import { logger } from '../../core/logger/index.server.js';
 import fs from 'fs';
 import { spawnSync } from 'node:child_process';

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

@@ -10,8 +10,13 @@ const createRelationsFacade = ({ db, tables }) => {
         const table = tables[relationTableName];
         if (!table)
             return true;
+        // Only some relation tables have a `locale` column at all — it's added
+        // only when the collection has at least one .localized() relation field
+        // (see getAll's identical guard below). Without this check, eq(undefined,
+        // locale) produces SQL with a missing column reference.
+        const columns = Object.keys(getTableColumns(table));
         const conditions = [eq(table.ownerId, ownerId)];
-        if (locale) {
+        if (locale && columns.includes('locale')) {
             conditions.push(eq(table.locale, locale));
         }
         const existingRelations = await db

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

@@ -5,7 +5,7 @@ import { flatten, unflatten } from 'flat';
 import { logger } from '../core/logger/index.server.js';
 import { extractFieldName } from '../fields/tree/util.js';
 import { isObjectLiteral, omit } from '../util/object.js';
-import { getBlocksTableNames, getTreeTableNames, makeBlockTableSlug, makeTreeTableSlug } from './generate-schema/util.js';
+import { getBlocksTableNames, getTreeTableNames, makeBlockTableSlug, makeTreeTableSlug } from './generate-schema/util.server.js';
 import { transformDatabaseColumnsToPaths } from './util.server.js';
 /**
  * Facade responsible of converting raw database document

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

@@ -69,12 +69,7 @@ export declare function prepareSchemaData(data: any, options: {
  * 4. Adds version fields while avoiding duplicates
  * 5. Includes the versionId in the result
  */
-export declare function mergeRawDocumentWithVersion(doc: RawDoc, versionTableName: string, select?: string[]): {
-    versionId: any;
-    id: string;
-} | {
-    versionId: any;
-};
+export declare function mergeRawDocumentWithVersion(doc: RawDoc, versionTableName: string, select?: string[]): RawDoc;
 /**
  * Build the query params to get either the latest updated document
  * or the published one if version.draft is enabled and draft is true

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

@@ -139,6 +139,8 @@ export function mergeRawDocumentWithVersion(doc, versionTableName, select) {
         // Filter out root props as they should come from the doc,
         // plus the ownerId wich is equals to doc.id
         const versionFields = omit([...rootProps, 'ownerId'], versionData);
+        // `pick`/`omit` return generic Dic types, so TS can't statically confirm
+        // `id` survived — it always does, since we explicitly pick it above.
         return {
             ...docFields,
             ...versionFields,
@@ -146,6 +148,10 @@ export function mergeRawDocumentWithVersion(doc, versionTableName, select) {
         };
     }
     // Default case - return all fields
+    // `versionTableName` is a plain `string`, not a literal, so `Omit<T, string>`
+    // widens to `Omit<T, keyof T>` and TS loses track of every spread key
+    // (including `id`) — the object is correct at runtime, only its inferred
+    // type collapses, hence the double cast through `unknown`.
     return {
         ...omit([versionTableName], doc),
         ...omit(['id', 'ownerId', 'createdAt', 'updatedAt'], versionData),

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

@@ -1,8 +1,8 @@
 import { RimeError } from '../core/errors/index.js';
-import { getFieldConfigByPath } from '../core/fields/util.js';
+import { getFieldAtPath } from '../core/fields/util.js';
 import { logger } from '../core/logger/index.server.js';
 import { hasVersionsSuffix, withLocalesSuffix } from '../core/naming.js';
-import { isRelationField } from '../fields/relation/index.js';
+import { RelationFieldBuilder } from '../fields/relation/index.js';
 import {} from '../index.js';
 import * as drizzleORM from 'drizzle-orm';
 import { and, eq, getTableColumns, inArray, or } from 'drizzle-orm';
@@ -65,9 +65,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         // Look for a relation field
         // Get document config
         const documentConfig = configCtx.getBySlug(slug);
-        // Get the compiled fields for lookups
-        const compiledFields = documentConfig.fields.map((f) => f.compile());
-        let fieldConfig = getFieldConfigByPath(column, compiledFields);
+        let fieldConfig = getFieldAtPath(column, documentConfig.fields);
         // Track relation-property detection (e.g. attributes.author.name)
         let matchedPrefix = column;
         let relationPropertyPath = null;
@@ -78,7 +76,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
             const parts = column.split('.');
             for (let i = parts.length - 1; i > 0; i--) {
                 const prefix = parts.slice(0, i).join('.');
-                const candidate = getFieldConfigByPath(prefix, compiledFields);
+                const candidate = getFieldAtPath(prefix, documentConfig.fields);
                 if (candidate) {
                     fieldConfig = candidate;
                     // If prefix shorter than original column, record the property suffix
@@ -92,7 +90,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
             }
         }
         // If still not found or not a relation field, log warning and return false condition
-        if (!fieldConfig || !isRelationField(fieldConfig)) {
+        if (!(fieldConfig instanceof RelationFieldBuilder)) {
             const message = `the query contains the field "${column}", not found for ${documentConfig.slug} document`;
             logger.warn(message);
             // Return a condition that will always be false instead of returning false
@@ -116,7 +114,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         // Handle relation property queries (e.g., attributes.author.name)
         // by building a subquery on the related collection
         const buildRelationPropertyCondition = () => {
-            const relatedSlug = fieldConfig.relationTo;
+            const relatedSlug = fieldConfig.get.relationTo;
             const relatedTable = getTable(relatedSlug);
             // Build a where clause for the related collection using the same operator/value
             const relatedWhere = { [relationPropertyPath]: { [operator]: rawValue } };
@@ -143,7 +141,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
             const ownersWithMatching = db
                 .select({ id: relsTable.ownerId })
                 .from(relsTable)
-                .where(and(inArray(relsTable[`${relatedSlug}Id`], matchingRelatedIds), eq(relsTable.path, matchedPrefix), ...(fieldConfig.localized ? [eq(relsTable.locale, locale)] : [])));
+                .where(and(inArray(relsTable[`${relatedSlug}Id`], matchingRelatedIds), eq(relsTable.path, matchedPrefix), ...(fieldConfig.get.localized ? [eq(relsTable.locale, locale)] : [])));
             return inArray(table.id, ownersWithMatching);
         };
         // If this is a relation property query, delegate to the relation property handler
@@ -152,19 +150,22 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         }
         // Handle direct relation field queries (e.g., attributes.author)
         // only support a subset of operators for multi-valued relations
-        // Unsupported operator for multi-valued relations :
         const supportedRelationManyOperators = ['equals', 'not_equals', 'in_array', 'not_in_array'];
         // Only enforce the restriction for direct relation field queries.
         // If this is a relation property query (e.g. attributes.author.name) we allow
         // any operator because those will be applied to the related collection.
-        if (fieldConfig.many && !supportedRelationManyOperators.includes(operator)) {
+        if (fieldConfig.get.many && !supportedRelationManyOperators.includes(operator)) {
             const unsupportedMessage = `the operator "${operator}" is not supported for multi-valued relation field "${column}" in ${documentConfig.slug} document`;
             logger.warn(unsupportedMessage);
             // Return a condition that will always be false
             return eq(table.id, '-1');
         }
         // Build relation condition
-        const [to, localized] = [fieldConfig.relationTo, fieldConfig.localized];
+        const [to, localized, many] = [
+            fieldConfig.get.relationTo,
+            fieldConfig.get.localized,
+            fieldConfig.get.many
+        ];
         const relsTableName = `${slug}Rels`;
         const relsTable = getTable(relsTableName);
         // Helpers for building common relation-owner subqueries (operate on the relations table)
@@ -197,7 +198,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
             .having(drizzleORM.gt(drizzleORM.count(relsTable.id), 0));
         // Handle multi-valued relations specially when operator is `equals` to provide
         // strict equality semantics (the relation set must equal the provided value(s)).
-        if (fieldConfig.many && operator === 'equals') {
+        if (many && operator === 'equals') {
             // Accept various input forms and normalize to a unique array
             const values = normalizeValues(rawValue, value);
             // Owners with total relation count equal to values.length
@@ -208,7 +209,7 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         }
         // For multi-valued relations, allow `in_array` to act as a subset check:
         // The provided values must contain ALL relation values of the document.
-        if (fieldConfig.many && operator === 'in_array') {
+        if (many && operator === 'in_array') {
             // Accept various input forms and normalize to a unique array
             const values = normalizeValues(rawValue, value);
             // Owners that have at least one relation row not included in the provided set
@@ -220,14 +221,14 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         }
         // For multi-valued relations, `not_in_array` should match documents where the provided
         // set does NOT contain all of the document's relation values (inverse of `in_array`).
-        if (fieldConfig.many && operator === 'not_in_array') {
+        if (many && operator === 'not_in_array') {
             // Accept various input forms and normalize to a unique array
             const values = normalizeValues(rawValue, value);
             const ownersWithNonMatching = buildOwnersWithNonMatching(values);
             return inArray(table.id, ownersWithNonMatching);
         }
         // For multi-valued relations, `not_equals` is the inverse of `equals` (exact-set inequality)
-        if (fieldConfig.many && operator === 'not_equals') {
+        if (many && operator === 'not_equals') {
             // Accept various input forms and normalize to a unique array
             const values = normalizeValues(rawValue, value);
             const ownersWithTotalCount = buildOwnersWithTotalCount(values.length);