rimecms 0.33.0 → 1.0.1

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

@@ -1,8 +1,6 @@
 import { getFieldAtPath, resolvedReferencesOf } from '../core/fields/util.js';
-import { BlocksBuilder } from '../fields/blocks/index.js';
 import { getColumns } from 'drizzle-orm';
 import { RelationFieldBuilder } from '../fields/relation/index.js';
-import { TreeBuilder } from '../fields/tree/index.js';
 import { baseTableName, childTableNames, joinName, tableName } from './naming.server.js';
 /** What a joined target is projected to, beside its `id`: whatever of these its table has. */
 const JOINED_COLUMNS = ['name', 'email', 'title', 'filename'];
@@ -14,7 +12,7 @@ const JOINED_COLUMNS = ['name', 'email', 'title', 'filename'];
  * `select`, only the selected ones.
  */
 export const resolvedReferenceJoins = (args) => {
-    const { table, tables, config, select } = args;
+    const { table, tables, config, select, resolve } = args;
     const isBase = table === baseTableName(config.slug);
     const withParam = {};
     for (const reference of resolvedReferencesOf(config.fields)) {
@@ -22,6 +20,8 @@ export const resolvedReferenceJoins = (args) => {
             continue;
         if (select?.length && !select.includes(reference.path))
             continue;
+        if (resolve && !resolve.includes(reference.path))
+            continue;
         const target = tables[baseTableName(reference.to)];
         if (!target)
             continue;
@@ -33,88 +33,96 @@ export const resolvedReferenceJoins = (args) => {
     }
     return withParam;
 };
+/** What a read of a page's address asks for: `url`, `_urlPath` and `_slug`, or all of the page. */
+const ADDRESS_PATHS = ['url', '_urlPath', '_slug'];
+/**
+ * The page's row in its paths table, in the locale read, when its collection has `$url`. A page
+ * has a row in every locale, so there is no fallback to resolve.
+ *
+ * ```ts
+ * pathsJoin({ base: 'pages', tables, locale: 'en' })
+ * // { 'pages__$paths': { where: { locale: 'en' }, columns: { slug: true, path: true, url: true } } }
+ * ```
+ */
+export const pathsJoin = (args) => {
+    const { base, tables, locale, select } = args;
+    const paths = tableName({ owner: base, child: { kind: 'paths' } });
+    if (!(paths in tables))
+        return {};
+    if (select?.length && !select.some((path) => ADDRESS_PATHS.includes(path)))
+        return {};
+    return {
+        [paths]: { where: { locale: locale ?? '' }, columns: { slug: true, path: true, url: true } }
+    };
+};
 export const buildWithParam = (args) => {
-    const { table, select = [], locale, fallback, tables, config: documentConfig } = args;
+    const { table, select = [], resolve, locale, fallback, tables, config: documentConfig } = args;
     // A child row — a block, a tree node — belongs to one locale. Its locales branch, and the
     // document's, are read for every locale in the order and merged in `transform`.
     const branchWhere = branchFilter(locale, fallback);
+    // On the base table only: a versioned read joins it above the content row.
+    const paths = table === baseTableName(documentConfig.slug)
+        ? pathsJoin({ base: table, tables, locale, select })
+        : {};
     if (!select.length) {
         return {
             ...buildFullWithParam({ table, locale, fallback, tables }),
-            ...resolvedReferenceJoins({ table, tables, config: documentConfig })
+            ...resolvedReferenceJoins({ table, tables, config: documentConfig, resolve }),
+            ...paths
         };
     }
-    const withParam = resolvedReferenceJoins({ table, tables, config: documentConfig, select });
-    // Track paths for different field types
+    const withParam = {
+        ...resolvedReferenceJoins({
+            table,
+            tables,
+            config: documentConfig,
+            select,
+            resolve
+        }),
+        ...paths
+    };
     const directRelationPaths = [];
-    const blockPaths = [];
-    const treePaths = [];
+    /** The selected paths stored as child tables, by the tables' kind. */
+    const childPaths = { blocks: [], tree: [] };
+    const allChildPaths = () => [...childPaths.blocks, ...childPaths.tree];
+    /** The kinds of child table a field's branches are stored in — none for a column. */
+    const storageKinds = (field) => [
+        ...new Set(field.use.nodes().flatMap((node) => (node.storage ? [node.storage.kind] : [])))
+    ];
     for (const path of select) {
         // Convert dot notation to double underscore notation for SQLite queries
         const sqlPath = path.replace(/\./g, '__');
         const fieldConfig = getFieldAtPath(path, documentConfig.fields);
+        // Each branch is where the field's rows are stored: the junction table, a child table, or a
+        // column of the row itself.
         if (fieldConfig instanceof RelationFieldBuilder) {
-            // Handle relation fields
             directRelationPaths.push(path);
         }
-        else if (fieldConfig instanceof BlocksBuilder) {
-            // Handle blocks fields
-            blockPaths.push(path);
-            const blocksTables = childTableNames(table, 'blocks', tables);
-            for (const blocksTable of blocksTables) {
-                if (!withParam[blocksTable]) {
+        else if (fieldConfig && storageKinds(fieldConfig).length) {
+            for (const kind of storageKinds(fieldConfig)) {
+                childPaths[kind].push(path);
+                for (const childTable of childTableNames(table, kind, tables)) {
+                    if (withParam[childTable])
+                        continue;
                     let params = { orderBy: { position: 'asc' } };
-                    const columns = getColumns(tables[blocksTable]);
+                    const columns = getColumns(tables[childTable]);
                     const hasLocale = Object.keys(columns).includes('locale');
                     if (locale && hasLocale) {
                         params = { ...params, where: { locale } };
                     }
-                    withParam[blocksTable] = params;
-                    // Handle localized blocks
-                    const localesBlockTable = tableName({ owner: blocksTable, branch: 'locales' });
-                    if (locale && localesBlockTable in tables) {
-                        withParam[blocksTable] = {
-                            ...withParam[blocksTable],
-                            with: {
-                                [localesBlockTable]: {
-                                    where: branchWhere
-                                }
-                            }
-                        };
-                    }
-                }
-            }
-        }
-        else if (fieldConfig instanceof TreeBuilder) {
-            // Handle tree fields
-            treePaths.push(path);
-            const treeTables = childTableNames(table, 'tree', tables);
-            for (const treeTable of treeTables) {
-                if (!withParam[treeTable]) {
-                    let params = { orderBy: { position: 'asc' } };
-                    const columns = getColumns(tables[treeTable]);
-                    const hasLocale = Object.keys(columns).includes('locale');
-                    if (locale && hasLocale) {
-                        params = { ...params, where: { locale } };
-                    }
-                    withParam[treeTable] = params;
-                    // Handle localized trees
-                    const localesTreeTables = tableName({ owner: treeTable, branch: 'locales' });
-                    if (locale && localesTreeTables in tables) {
-                        withParam[treeTable] = {
-                            ...withParam[treeTable],
-                            with: {
-                                [localesTreeTables]: {
-                                    where: branchWhere
-                                }
-                            }
+                    withParam[childTable] = params;
+                    // Its locales branch with it.
+                    const localesTable = tableName({ owner: childTable, branch: 'locales' });
+                    if (locale && localesTable in tables) {
+                        withParam[childTable] = {
+                            ...withParam[childTable],
+                            with: { [localesTable]: { where: branchWhere } }
                         };
                     }
                 }
             }
         }
         else if (fieldConfig) {
-            // Handle regular fields
             if (fieldConfig.get.localized && locale) {
                 const localesTableName = tableName({ owner: table, branch: 'locales' });
                 if (localesTableName in tables) {
@@ -147,7 +155,7 @@ export const buildWithParam = (args) => {
     // 1. Include relations table if container paths exist (blocks or trees).
     //    If container paths are present we include relations for those containers
     //    and also include any direct relation paths.
-    if ((blockPaths.length > 0 || treePaths.length > 0) &&
+    if (allChildPaths().length > 0 &&
         tableName({ owner: table, child: { kind: 'rels' } }) in tables) {
         // Create a where condition that matches relations within any of the container paths,
         // and include direct relation paths as exact matches.
@@ -155,7 +163,7 @@ export const buildWithParam = (args) => {
             where: {
                 OR: [
                     // A container's rows sit under its path; a direct relation is the path itself.
-                    ...[...blockPaths, ...treePaths].map((path) => ({ path: { like: `${path}__%` } })),
+                    ...allChildPaths().map((path) => ({ path: { like: `${path}__%` } })),
                     ...directRelationPaths.map((path) => ({ path }))
                 ]
             },
@@ -163,12 +171,12 @@ export const buildWithParam = (args) => {
         };
     }
     // 2. Include tree tables for blocks that might contain trees
-    if (blockPaths.length > 0) {
+    if (childPaths.blocks.length > 0) {
         const treeTables = childTableNames(table, 'tree', tables);
         for (const treeTable of treeTables) {
             if (!withParam[treeTable]) {
                 withParam[treeTable] = {
-                    where: { OR: blockPaths.map((path) => ({ path: { like: `${path}__%` } })) },
+                    where: { OR: childPaths.blocks.map((path) => ({ path: { like: `${path}__%` } })) },
                     orderBy: { position: 'asc' }
                 };
                 // Handle localized trees
@@ -187,12 +195,12 @@ export const buildWithParam = (args) => {
         }
     }
     // 3. Include block tables for trees that might contain blocks
-    if (treePaths.length > 0) {
+    if (childPaths.tree.length > 0) {
         const blocksTables = childTableNames(table, 'blocks', tables);
         for (const blocksTable of blocksTables) {
             if (!withParam[blocksTable]) {
                 withParam[blocksTable] = {
-                    where: { OR: treePaths.map((path) => ({ path: { like: `${path}__%` } })) },
+                    where: { OR: childPaths.tree.map((path) => ({ path: { like: `${path}__%` } })) },
                     orderBy: { position: 'asc' }
                 };
                 // Handle localized blocks

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

@@ -1,6 +1,6 @@
 import type { TableHandle } from '../core/adapter.js';
 import type { GetRegisterType } from '../index.js';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { SqliteDatabase } from './types.server.js';
 /**
  * Handles for the tables features declared — see `FeatureDefinition.tables`.
  *
@@ -13,6 +13,6 @@ import type { LibSQLDatabase } from 'drizzle-orm/libsql';
  * had no way to name until a feature could declare one.
  */
 export declare const createTableHandles: (args: {
-    db: LibSQLDatabase<GetRegisterType<"Relations">>;
+    db: SqliteDatabase;
     tables: GetRegisterType<"Tables">;
 }) => (slug: string) => TableHandle;

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

@@ -2,9 +2,9 @@ import { getTableColumns } from 'drizzle-orm';
 import { flatten } from 'flat';
 import { logger } from '../core/logger.server.js';
 import { extractFieldName } from '../fields/tree/util.js';
-import { omit } from '../util/object.js';
+import { isObjectLiteral, omit } from '../util/object.js';
 import { baseTableName, tableName as buildTableName, childTableNames, joinName } from './naming.server.js';
-import { transformDatabaseColumnsToPaths } from './columns.server.js';
+import { databaseColumnToPath, transformDatabaseColumnsToPaths } from './columns.server.js';
 import { localeOrder, mergeLocaleRows } from './locales.server.js';
 import { resolvedReferencesOf } from '../core/fields/util.js';
 /**
@@ -42,6 +42,8 @@ export const createTransformHandle = (args) => {
         // the config rather than asked of a feature, which is what keeps this file naming none.
         const tableName = baseTableName(configCtx.getBySlug(slug)._versions?.slug ?? slug);
         const tableNameRelationFields = buildTableName({ owner: tableName, child: { kind: 'rels' } });
+        // The addresses hang off the base row, whether or not the content is on a versions table.
+        const tableNamePaths = buildTableName({ owner: baseTableName(slug), child: { kind: 'paths' } });
         const tableNameLocales = buildTableName({ owner: tableName, branch: 'locales' });
         /** Add localized fields, each from the first locale in the fallback order that holds it. */
         if (locale && tableNameLocales in tables && doc[tableNameLocales]) {
@@ -109,7 +111,35 @@ export const createTransformHandle = (args) => {
         // The child tables came back on the same row; they are their own piles now. Left on, they
         // flatten into `pages__$blocks_hero.0.id` keys that survive every step to be stripped by name
         // at the very end.
-        const base = transformDatabaseColumnsToPaths(flatten(omit([...blocksTables, ...treeTables, tableNameRelationFields], doc)));
+        // One pass over the row: a child table's key is dropped, a column becomes its path, and a
+        // JSON value — an object or an array — is flattened under it, nothing else is walked.
+        const childTables = new Set([
+            ...blocksTables,
+            ...treeTables,
+            tableNameRelationFields,
+            tableNamePaths
+        ]);
+        const base = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (childTables.has(key))
+                continue;
+            if (isObjectLiteral(value) || Array.isArray(value)) {
+                for (const [flatKey, flatValue] of Object.entries(flatten({ [key]: value }))) {
+                    base[databaseColumnToPath(flatKey)] = flatValue;
+                }
+            }
+            else {
+                base[databaseColumnToPath(key)] = value;
+            }
+        }
+        // The page's address in the locale read: `url`, `_urlPath` and `_slug` on the document. Not
+        // `_path`, which an upload collection already names.
+        if (tableNamePaths in doc) {
+            const [address] = doc[tableNamePaths] ?? [];
+            base.url = address?.url ?? null;
+            base._urlPath = address?.path ?? null;
+            base._slug = address?.slug ?? null;
+        }
         return { base, blocks, tree, relations };
     };
     return { rows };

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

@@ -1,12 +1,19 @@
 import type { GetRegisterType } from '../index.js';
 import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { SQLiteAsyncDatabase, SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+/**
+ * The drizzle connection, whichever driver opened it.
+ *
+ * libsql is async and bun:sqlite is sync, but drizzle wraps both in `SQLiteAsyncDatabase`, so
+ * every query is awaited the same way. The one difference that leaks: a sync driver's
+ * `db.transaction()` rejects an async callback.
+ */
+export type SqliteDatabase = SQLiteAsyncDatabase<'sync' | 'async', unknown, GetRegisterType<'Relations'>>;
 /**
  * What every facade in this folder is built from: the connection and the generated tables.
  */
 export type AdapterDeps = {
-    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
+    db: SqliteDatabase;
     tables: GenericTables;
 };
 type GenericColumn = SQLiteColumn<ColumnBaseConfig<ColumnDataType>, Record<string, unknown>>;

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

@@ -1,14 +1,13 @@
 import type { ConfigContext } from '../core/rime.server.js';
 import { type GetRegisterType } from '../index.js';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { ParsedQs } from 'qs';
 import type { PrototypeSlug } from '../types.js';
-import type { GenericTable } from './types.server.js';
+import type { GenericTable, SqliteDatabase } from './types.server.js';
 type BuildWhereArgs = {
     query: ParsedQs;
     slug: PrototypeSlug;
     locale?: string;
-    db: LibSQLDatabase<GetRegisterType<'Relations'>>;
+    db: SqliteDatabase;
     tables: GetRegisterType<'Tables'>;
     configCtx: ConfigContext;
     /**

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

@@ -52,6 +52,16 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx, ba
         const { 
         // Get condition members
         column, sqlColumn, fn, operator, rawValue, value } = getConditionMembers(conditionObject);
+        // A collection with `$url` finds its pages by url or by path through its paths table, in the
+        // locale read. A versions table is matched through its `ownerId`, like any base-row filter.
+        const pathsTable = getTable(tableName({ owner: baseTableName(base ?? slug), child: { kind: 'paths' } }));
+        if (pathsTable && (column === 'url' || column === '_urlPath')) {
+            const owners = db
+                .select({ id: pathsTable.ownerId })
+                .from(pathsTable)
+                .where(and(eq(pathsTable.locale, locale ?? ''), fn(column === 'url' ? pathsTable.url : pathsTable.path, value)));
+            return inArray(isShadow ? table.ownerId : table.id, owners);
+        }
         // Handle regular fields
         if (unlocalizedColumns.includes(sqlColumn)) {
             return fn(table[sqlColumn], value);
@@ -66,7 +76,15 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx, ba
             const resolved = order.length > 1
                 ? sql `COALESCE(${sql.join(order.map(valueIn), sql `, `)})`
                 : valueIn(order[0]);
-            return fn(resolved, value);
+            if (operator !== 'equals' && operator !== 'in_array')
+                return fn(resolved, value);
+            // A document whose read value matches has a locales row holding it, so the documents with
+            // one are asked first: that is what an index on the column answers, and the comparison
+            // above then runs on those alone.
+            return and(inArray(table.id, db
+                .select({ ownerId: tableLocales.ownerId })
+                .from(tableLocales)
+                .where(fn(tableLocales[sqlColumn], value))), fn(resolved, value));
         }
         // A column the base row keeps — the hierarchy columns, and any `$root()` field — reached
         // through `ownerId` when the table queried is the versions table.

package/dist/core/adapter.d.ts

@@ -55,6 +55,7 @@ export interface Adapter {
     blocks: BlocksHandle;
     tree: TreeHandle;
     relations: RelationsHandle;
+    paths: PathsHandle;
     transform: TransformHandle;
     auth: AuthHandle;
 }
@@ -78,6 +79,12 @@ export interface BaseHandle {
         locale?: string;
         /** See `find`. */
         localeFallback?: boolean;
+        /**
+         * The resolved references to join, by document path. Absent, every one; `select` narrows
+         * further. A read hands down the ones its reader may see, so a join is never made for a
+         * field the pipeline goes on to drop.
+         */
+        resolve?: string[];
         /** Per document, which content row — see `find`. Filters the list as well as picking rows. */
         content?: OperationQuery;
     }): Promise<RawDoc[]>;
@@ -119,6 +126,8 @@ export interface CollectionHandle extends BaseHandle {
          * else, which is what a copy from one row to another reads.
          */
         localeFallback?: boolean;
+        /** See `findMany`. */
+        resolve?: string[];
         /**
          * Narrows which content row this read means, for a config that has one. The newest when
          * omitted, which is what "the content of this document" means with nothing else said.
@@ -191,6 +200,8 @@ export interface AreaHandle extends BaseHandle {
         locale?: string;
         /** See `CollectionHandle.find`. */
         localeFallback?: boolean;
+        /** See `CollectionHandle.findMany`. */
+        resolve?: string[];
         content?: OperationQuery;
     }): Promise<RawDoc | undefined>;
     /** Writes the rows a write plan names. See `CollectionHandle.update`. */
@@ -275,6 +286,93 @@ export interface RelationsHandle {
         locale?: string;
     }): Promise<Relation[]>;
 }
+/**
+ * A page's address in one locale, as a collection with `$url` stores it.
+ *
+ * ```
+ * { ownerId: 'web', locale: 'en', slug: 'web', path: 'services/web', url: 'https://site.test/en/services/web' }
+ * ```
+ *
+ * `locale` is `''` when the config has no localization. `path` is the slugs from the top page down
+ * to this one; the adapter keeps it in step when a slug changes or a page moves.
+ */
+export type PathRow = {
+    ownerId: string;
+    locale: string;
+    slug: string;
+    path: string;
+    url: string | null;
+};
+/**
+ * The addresses of a collection's pages. Every verb names one page; the pages under it follow.
+ */
+export interface PathsHandle {
+    /** One row per locale for a new page, under its parent's row in each locale. */
+    insert(args: {
+        slug: PrototypeSlug;
+        ownerId: string;
+        parentId: string | null;
+        rows: {
+            locale: string;
+            slug: string;
+        }[];
+    }): Promise<PathRow[]>;
+    /** The page's rows, in every locale unless one is given. */
+    get(args: {
+        slug: PrototypeSlug;
+        ownerId: string;
+        locale?: string;
+    }): Promise<PathRow[]>;
+    /** A new slug in one locale. Answers the row with its new path. */
+    setSlug(args: {
+        slug: PrototypeSlug;
+        ownerId: string;
+        locale: string;
+        value: string;
+    }): Promise<PathRow | undefined>;
+    /**
+     * Under another parent, or at the top, with the slug it takes there in each of its locales:
+     * `{ en: 'team', fr: 'equipe' }`. Answers the page's rows.
+     */
+    moveUnder(args: {
+        slug: PrototypeSlug;
+        ownerId: string;
+        parentId: string | null;
+        slugs: Record<string, string>;
+    }): Promise<PathRow[]>;
+    /** The pages directly under this one, in any locale. */
+    children(args: {
+        slug: PrototypeSlug;
+        ownerId: string;
+    }): Promise<string[]>;
+    /** The row at `path` and, with `withDescendants`, every row below it, in one locale. */
+    under(args: {
+        slug: PrototypeSlug;
+        locale: string;
+        path: string;
+        withDescendants?: boolean;
+    }): Promise<PathRow[]>;
+    /** The slugs the children of `parentId` hold in `locale`, or of the top pages when it is null. */
+    siblingSlugs(args: {
+        slug: PrototypeSlug;
+        locale: string;
+        parentId: string | null;
+    }): Promise<string[]>;
+    /** The documents of the collection with no row in `locale` yet. */
+    missingOwners(args: {
+        slug: PrototypeSlug;
+        locale: string;
+    }): Promise<string[]>;
+    /** New urls, in one transaction. */
+    setUrls(args: {
+        slug: PrototypeSlug;
+        rows: {
+            ownerId: string;
+            locale: string;
+            url: string;
+        }[];
+    }): Promise<void>;
+}
 export interface TransformHandle {
     /**
      * The rows one document is stored across, unflattened and grouped by what they are.

package/dist/core/auth/better-auth/config.server.d.ts

@@ -1257,7 +1257,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     $Infer: {
                         body: {
                             userId: string;
-                            role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                            role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
                         };
                     };
                 };
@@ -1346,7 +1346,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             email: string;
                             password?: string | undefined;
                             name: string;
-                            role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                            role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
                             data?: Record<string, any> | undefined;
                         };
                     };
@@ -1970,7 +1970,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             };
                         } & {
                             userId?: string | undefined;
-                            role?: "user" | "admin" | "staff" | undefined;
+                            role?: "user" | "staff" | "admin" | undefined;
                         };
                     };
                 };

package/dist/core/auth/better-auth/instance.server.d.ts

@@ -1273,7 +1273,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                     $Infer: {
                         body: {
                             userId: string;
-                            role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                            role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
                         };
                     };
                 };
@@ -1362,7 +1362,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                             email: string;
                             password?: string | undefined;
                             name: string;
-                            role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                            role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
                             data?: Record<string, any> | undefined;
                         };
                     };
@@ -1986,7 +1986,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                             };
                         } & {
                             userId?: string | undefined;
-                            role?: "user" | "admin" | "staff" | undefined;
+                            role?: "user" | "staff" | "admin" | undefined;
                         };
                     };
                 };
@@ -3344,7 +3344,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                     $Infer: {
                         body: {
                             userId: string;
-                            role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                            role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
                         };
                     };
                 };
@@ -3433,7 +3433,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                             email: string;
                             password?: string | undefined;
                             name: string;
-                            role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                            role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
                             data?: Record<string, any> | undefined;
                         };
                     };
@@ -4057,7 +4057,7 @@ export declare const createAuthInstance: <const C extends Config>(args: {
                             };
                         } & {
                             userId?: string | undefined;
-                            role?: "user" | "admin" | "staff" | undefined;
+                            role?: "user" | "staff" | "admin" | undefined;
                         };
                     };
                 };

package/dist/core/auth/handler/index.server.js

@@ -1,6 +1,6 @@
 import { RimeError } from '../../errors/index.js';
 import { error, redirect } from '@sveltejs/kit';
-import { access } from '../../../util/index.js';
+import { access } from '../access.js';
 import { BETTER_AUTH_ROLES } from '../constant.server.js';
 import { userAttributes } from '../user.server.js';
 import { hasAuthUser } from '../better-auth-tables.server.js';

package/dist/core/auth/staff/derive.js

@@ -1,4 +1,4 @@
-import { access } from '../../../util/index.js';
+import { access } from '../access.js';
 import { UsersRound } from '@lucide/svelte';
 import cloneDeep from 'clone-deep';
 export const staffCollection = {

package/dist/core/auth/validate-config.js

@@ -1,4 +1,3 @@
-import { isFormField } from '../fields/util.js';
 import { SelectFieldBuilder } from '../../fields/select/index.js';
 /**
  * What a collection declaring `auth` has to look like.
@@ -22,12 +21,11 @@ export const validateAuth = (config) => {
     if (config.versions) {
         errors.push(`Auth collections can't be versionned (${config.slug})`);
     }
-    const formFields = config.fields.filter(isFormField);
-    const rolesField = formFields
+    const rolesField = config.fields
         .filter((f) => f.name === 'roles')
         .filter((f) => f instanceof SelectFieldBuilder)[0];
-    const nameField = formFields.filter((f) => f.name === 'name')[0];
-    const emailField = formFields.find((f) => f.name === 'email' && f.type === 'email');
+    const nameField = config.fields.filter((f) => f.name === 'name')[0];
+    const emailField = config.fields.find((f) => f.name === 'email' && f.type === 'email');
     if (!rolesField)
         errors.push(`Field roles is missing in collection ${config.slug}`);
     if (!emailField && config.auth?.type !== 'apiKey')