rimecms 0.31.5 → 0.32.1

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

@@ -1,17 +1,39 @@
-import type { LocaleConfig } from '../../core/config/types.js';
+import type { LocaleConfig } from '../../core/locale/types.js';
 import { type FieldBuilder } from '../../core/fields/builders/field-builder.js';
 import type { Field } from '../../fields/types.js';
-import type { RelationFieldsMap } from './relations/definition.server.js';
+import type { TableName } from '../naming.server.js';
+import type { ColumnDeclaration } from '../../core/adapter.js';
+/** A relation field on a prototype: which collection it points at, and whether it is localized. */
+export type RelationFieldsMap = Record<string, {
+    to: string;
+    localized?: boolean;
+}>;
+/** A reference the read resolves: the table and column holding the foreign key, and its target. */
+export type ReferenceJoin = {
+    table: TableName;
+    column: string;
+    to: string;
+};
 type Args = {
     fields: FieldBuilder<Field>[];
-    tableName: string;
-    rootName: string;
+    tableName: TableName;
+    rootName: TableName;
     locales?: LocaleConfig[];
     hasParent?: boolean;
     relationFieldsMap?: RelationFieldsMap;
     relationsDic?: Record<string, string[]>;
-    hasAuth?: boolean;
-    versionsFrom?: string | false;
+    /**
+     * Storage-only columns to append to this config's table, in order.
+     *
+     * Appended as given; nothing here knows what asked for them.
+     */
+    featureColumns?: ColumnDeclaration[];
+    /**
+     * The base table this one holds the content of, when it is a versions table — it gets an `ownerId` pointing back at
+     * it. Named after the relationship rather than after the feature that asks for one: what makes
+     * a versions table is a feature declaring one, never a config member this module recognises.
+     */
+    versionsOf?: string | false;
     blocksRegister: string[];
 };
 type Return = {
@@ -19,11 +41,13 @@ type Return = {
     relationFieldsMap: RelationFieldsMap;
     relationsDic: Record<string, string[]>;
     relationFieldsHasLocale: boolean;
+    /** Every resolved reference on this table and its blocks and tree tables. */
+    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.
  */
-declare const buildRootTable: ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap, relationsDic, hasAuth, versionsFrom, blocksRegister }: Args) => Promise<Return>;
+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,22 +1,21 @@
 import {} from '../../core/fields/builders/field-builder.js';
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
-import { withLocalesSuffix } from '../../core/naming.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 { tableName as buildTableName, getSchemaColumnNames } from '../naming.server.js';
 import { toSchemaColumn } from './column.server.js';
-import { templateHasAuth, templateLocale, templateParent, templateTable } from './templates.server.js';
-const p = toPascalCase;
+import { templateDeclaredColumn, templateLocale, templateParent, templateTable } from './templates.server.js';
 /**
  * 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.
  */
-const buildRootTable = async ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap = {}, relationsDic = {}, hasAuth, versionsFrom, blocksRegister }) => {
+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 = '') => {
         let templates = [];
@@ -52,7 +51,10 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
             }
             else if (field instanceof BlocksBuilder) {
                 for (const block of field.get.blocks) {
-                    const blockTableName = `${rootName}Blocks${p(block.name)}`;
+                    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 = {
@@ -60,7 +62,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                             [rootName]: [...(relationsDic[rootName] || []), blockTableName]
                         };
                         // Build the child blocks table
-                        const { schema: blockTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale } = await buildRootTable({
+                        const { schema: blockTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale, referenceJoins: nestedReferenceJoins } = await buildRootTable({
                             blocksRegister,
                             fields: block.get.fields,
                             tableName: blockTableName,
@@ -74,20 +76,24 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                         relationFieldsMap = nestedRelationFieldsDic;
                         if (nestedRelationFieldsHasLocale)
                             relationFieldsHasLocale = true;
+                        referenceJoins.push(...nestedReferenceJoins);
                         blocksRegister.push(blockTableName);
                         blocksTables.push(blockTable);
                     }
                 }
             }
             else if (field instanceof TreeBuilder) {
-                const treeTableName = `${rootName}Tree${p(field.name)}`;
+                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 } = await buildRootTable({
+                    const { schema: treeTable, relationsDic: nestedRelationsDic, relationFieldsMap: nestedRelationFieldsDic, relationFieldsHasLocale: nestedRelationFieldsHasLocale, referenceJoins: nestedReferenceJoins } = await buildRootTable({
                         blocksRegister,
                         fields: field.get.fields,
                         tableName: treeTableName,
@@ -101,6 +107,7 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
                     relationFieldsMap = nestedRelationFieldsDic;
                     if (nestedRelationFieldsHasLocale)
                         relationFieldsHasLocale = true;
+                    referenceJoins.push(...nestedReferenceJoins);
                     blocksRegister.push(treeTableName);
                     blocksTables.push(treeTable);
                 }
@@ -108,6 +115,14 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
             else if (field instanceof FormFieldBuilder) {
                 if (checkLocalized(field)) {
                     templates.push(toSchemaColumn(field, parentPath) + ',');
+                    // A reference the read resolves gets a relation to its target beside the column.
+                    if (field._references?.resolve) {
+                        referenceJoins.push({
+                            table: tableName,
+                            column: getSchemaColumnNames({ name: field.name, parentPath }).camel,
+                            to: field._references.table
+                        });
+                    }
                 }
             }
         }
@@ -115,18 +130,18 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
     };
     let table;
     if (locales && locales.length && hasLocalizedField(incomingFields)) {
-        const tableNameLocales = withLocalesSuffix(tableName);
+        const tableNameLocales = buildTableName({ owner: tableName, branch: 'locales' });
         const strLocalizedFields = await generateFieldsTemplates(incomingFields, true);
         relationsDic[tableName] = [...(relationsDic[tableName] || []), tableNameLocales];
         const strUnlocalizedFields = await generateFieldsTemplates(incomingFields, false);
         if (hasParent) {
             strUnlocalizedFields.push(templateParent(rootName));
         }
-        if (versionsFrom) {
-            strUnlocalizedFields.push(templateParent(versionsFrom));
+        if (versionsOf) {
+            strUnlocalizedFields.push(templateParent(versionsOf));
         }
-        if (hasAuth) {
-            strUnlocalizedFields.push(templateHasAuth(rootName));
+        for (const column of featureColumns) {
+            strUnlocalizedFields.push(templateDeclaredColumn(column) + ',');
         }
         table = templateTable(tableName, strUnlocalizedFields.join('\n  '));
         table += templateTable(tableNameLocales, [...strLocalizedFields, templateLocale(), templateParent(tableName)].join('\n  '));
@@ -136,11 +151,11 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         if (hasParent) {
             strFields.push(templateParent(rootName));
         }
-        if (versionsFrom) {
-            strFields.push(templateParent(versionsFrom));
+        if (versionsOf) {
+            strFields.push(templateParent(versionsOf));
         }
-        if (hasAuth) {
-            strFields.push(templateHasAuth(rootName));
+        for (const column of featureColumns) {
+            strFields.push(templateDeclaredColumn(column) + ',');
         }
         table = templateTable(tableName, strFields.join('\n  '));
     }
@@ -148,7 +163,8 @@ const buildRootTable = async ({ fields: incomingFields, tableName, rootName, has
         schema: [table, ...blocksTables].join('\n\n'),
         relationFieldsMap,
         relationFieldsHasLocale,
-        relationsDic
+        relationsDic,
+        referenceJoins
     };
 };
 function hasLocalizedField(fields) {

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

@@ -1,9 +1,10 @@
 import type { FieldReference } from '../../core/fields/builders/form-field-builder.js';
+import type { ColumnDeclaration, TableDeclaration } from '../../core/adapter.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 { relations } from 'drizzle-orm';\n\nconst pk = () => text(\"id\").primaryKey().$defaultFn(() => crypto.randomUUID());\n";
+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";
 /**
  * Generates a basic table definition with a primary key
  * Takes a table name and optional content for additional columns
@@ -49,15 +50,26 @@ export declare const templateParent: (parent: string) => string;
  */
 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
+ * One column of a `TableDeclaration`, or one a feature puts on a prototype's own table.
+ *
+ * A `references` names a slug, so it resolves here — the same rule `templateReferences` follows
+ * for a field-level foreign key, and for the same reason: which table a slug lives in is the
+ * adapter's business.
  *
  * @example
  * ```typescript
- * authUserId: text("auth_user_id").references(() => authUsers.id).notNull(),
+ * authUserId: text('auth_user_id').notNull().references(() => authUsers.id, { onDelete: 'cascade' })
  * ```
  */
-export declare const templateHasAuth: (slug: string) => string;
+export declare const templateDeclaredColumn: (column: ColumnDeclaration) => string;
+/**
+ * A table a feature declared: `templateAuth`, `templateAPIKey` and `templateDirectories` were
+ * three hand-written copies of this, and the schema generator had to know each by name to push it.
+ *
+ * Exported under the slug's own name and stored under the snake-cased one — see
+ * `declaredTableProperty`. No `pk()` default: a declaration says which column is the primary key.
+ */
+export declare const templateDeclaredTable: (table: TableDeclaration) => string;
 /**
  * Generates unique and required modifiers for a field
  * Combines .unique() and .notNull() based on field configuration
@@ -80,44 +92,54 @@ export declare const templateUniqueRequired: (field: {
 }, defaultValue?: string | number | boolean | object | unknown[]) => string;
 /** Template rows Relation */
 /**
- * Generates a one-to-one or many-to-one relationship definition
- * Creates a relation where the table has one parent
- *
- * @example
- * ```typescript
- * export const rel_pagesVersionsHasOnePages = relations(pagesVersions, ({ one }) => ({
- *   pages: one(pages, {
- *     fields: [pagesVersions.ownerId],
- *     references: [pages.id],
- *   }),
- * }))
+ * The whole schema's relations, in one declaration.
+ *
+ * Every relation rime generates is the same shape — a child row points at its owner through
+ * `ownerId` — so the tree is `parent -> children` and both directions fall out of it:
+ *
+ * ```ts
+ * export const relations = defineRelations(tables, (r) => ({
+ *   pages: {
+ *     pages__$blocks_paragraph: r.many.pages__$blocks_paragraph({
+ *       from: r.pages.id, to: r.pages__$blocks_paragraph.ownerId
+ *     })
+ *   },
+ *   pages__$blocks_paragraph: {
+ *     pages: r.one.pages({ from: r.pages__$blocks_paragraph.ownerId, to: r.pages.id })
+ *   }
+ * }));
  * ```
- */
-export declare const templateRelationOne: ({ name, table, parent }: RelationOneArgs) => string;
-/**
- * Generates a one-to-many relationship definition
- * Creates a relation where the table has many children
  *
- * @example
- * ```typescript
- * export const rel_pagesHasManyBlocks = relations(pages, ({ many }) => ({
- *   pagesBlocksParagraph: many(pagesBlocksParagraph),
- *   pagesBlocksImage: many(pagesBlocksImage),
- * }))
+ * A relation is keyed by the table on the other end, which is what `buildWithParam` names when it
+ * builds a `with`.
+ *
+ * A reference the read resolves is the other shape: the owner's row points at its target through
+ * the field's own column, one direction, keyed by `joinName(column)`:
+ *
+ * ```ts
+ * pages: {
+ *   updatedBy__$doc: r.one.staff({ from: r.pages.updatedBy, to: r.staff.id })
+ * }
  * ```
  */
-export declare const templateRelationMany: ({ name, table, many }: RelationManyArgs) => string;
+export declare const templateRelations: (tree: Record<string, string[]>, referenceJoins?: {
+    table: string;
+    column: string;
+    to: string;
+}[]) => string;
 /** Templates Field Relations */
 /**
- * Generates a foreign key column for a relation field
- * Creates a reference to another table's primary key with cascade delete
+ * The junction column pointing at one target collection. The property is keyed by the slug, which
+ * is how the adapter reads it back; the SQL column and the referenced table carry the table name.
  *
- * @example
- * ```typescript
+ * ```ts
+ * // 'medias'
  * mediasId: text('medias_id').references(() => medias.id, { onDelete: 'cascade' })
+ * // 'eventsCategories'
+ * eventsCategoriesId: text('events_categories_id').references(() => events_categories.id, { onDelete: 'cascade' })
  * ```
  */
-export declare const templateFieldRelationColumn: (table: string) => string;
+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
@@ -135,7 +157,7 @@ export declare const templateFieldRelationColumn: (table: string) => string;
  * })
  * ```
  */
-export declare const templateRelationFieldsTable: ({ table, relations, hasLocale }: FieldsRelationTableArgs) => string;
+export declare const templateRelationFieldsTable: ({ table, junctionTable, relations, hasLocale }: FieldsRelationTableArgs) => string;
 /**
  * Generates an export of relation field mappings for runtime use
  * Creates a record mapping table names to their relation configurations
@@ -157,21 +179,11 @@ export declare const templateExportRelationsFieldsToTable: (relationFieldsDic: R
  * export const tables = {
  *   pages,
  *   pagesBlocksParagraph,
- *   pagesBlocksImage,
- *   authUsers,
- *   authAccounts,
- *   authVerifications,
- *   authSessions
+ *   pagesBlocksImage
  * }
  * ```
  */
 export declare const templateExportTables: (tables: string[]) => string;
-/**
- * Generates authentication tables for the schema
- * Creates tables for users, sessions, accounts, and verifications
- */
-export declare const templateAuth = "\nexport const authUsers = sqliteTable('auth_users', {\n\tid: text('id').primaryKey(),\n\tname: text('name').notNull(),\n\temail: text('email').notNull().unique(),\n\temailVerified: integer('email_verified', { mode: 'boolean' }).notNull(),\n\timage: text('image'),\n\tcreatedAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),\n\tupdatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),\n\trole: text('role'),\n\tbanned: integer('banned', { mode: 'boolean' }),\n\tbanReason: text('ban_reason'),\n\tbanExpires: integer('ban_expires', { mode: 'timestamp_ms' }),\n\ttype: text('type').notNull()\n  });\n\nexport const authSessions = sqliteTable('auth_sessions', {\n\tid: text('id').primaryKey(),\n\texpiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),\n\ttoken: text('token').notNull().unique(),\n\tcreatedAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),\n\tupdatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),\n\tipAddress: text('ip_address'),\n\tuserAgent: text('user_agent'),\n\tuserId: text('user_id')\n\t\t.notNull()\n\t\t.references(() => authUsers.id, { onDelete: 'cascade' }),\n\timpersonatedBy: text('impersonated_by')\n  });\n\nexport const authAccounts = sqliteTable('auth_accounts', {\n\tid: text('id').primaryKey(),\n\taccountId: text('account_id').notNull(),\n\tissuer: text('issuer').notNull(),\n\tproviderId: text('provider_id').notNull(),\n\tuserId: text('user_id')\n\t\t.notNull()\n\t\t.references(() => authUsers.id, { onDelete: 'cascade' }),\n\taccessToken: text('access_token'),\n\trefreshToken: text('refresh_token'),\n\tidToken: text('id_token'),\n\taccessTokenExpiresAt: integer('access_token_expires_at', { mode: 'timestamp_ms' }),\n\trefreshTokenExpiresAt: integer('refresh_token_expires_at', { mode: 'timestamp_ms' }),\n\tscope: text('scope'),\n\tpassword: text('password'),\n\tcreatedAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),\n\tupdatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull()\n  });\n\nexport const authVerifications = sqliteTable('auth_verifications', {\n\tid: text('id').primaryKey(),\n\tidentifier: text('identifier').notNull(),\n\tvalue: text('value').notNull(),\n\texpiresAt: integer('expires_at', { mode: 'timestamp_ms' }).notNull(),\n\tcreatedAt: integer('created_at', { mode: 'timestamp_ms' }),\n\tupdatedAt: integer('updated_at', { mode: 'timestamp_ms' })\n  });\n";
-export declare const templateAPIKey = "\nexport const apikey = sqliteTable(\"apikey\", {\n\tid: text('id').primaryKey(),\n\tname: text('name'),\n\tstart: text('start'),\n\tprefix: text('prefix'),\n\tkey: text('key').notNull(),\n\treferenceId: text('reference_id').notNull().references(()=> authUsers.id, { onDelete: 'cascade' }),\n\tconfigId: text('config_id').notNull().default('default'),\n\trefillInterval: integer('refill_interval'),\n\trefillAmount: integer('refill_amount'),\n\tlastRefillAt: integer('last_refill_at', { mode: 'timestamp' }),\n\tenabled: integer('enabled', { mode: 'boolean' }).default(true),\n\trateLimitEnabled: integer('rate_limit_enabled', { mode: 'boolean' }).default(true),\n\trateLimitTimeWindow: integer('rate_limit_time_window').default(86400000),\n\trateLimitMax: integer('rate_limit_max').default(10),\n\trequestCount: integer('request_count'),\n\tremaining: integer('remaining'),\n\tlastRequest: integer('last_request', { mode: 'timestamp' }),\n\texpiresAt: integer('expires_at', { mode: 'timestamp' }),\n\tcreatedAt: integer('created_at', { mode: 'timestamp' }).notNull(),\n\tupdatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),\n\tpermissions: text('permissions'),\n\tmetadata: text('metadata')\n});\n";
 /**
  * Generates the final schema export with all tables and relations
  * Creates a schema object and exports it with proper TypeScript types
@@ -180,13 +192,9 @@ export declare const templateAPIKey = "\nexport const apikey = sqliteTable(\"api
  * ```typescript
  * const schema = {
  *   pages,
- *   pagesVersions,
- *   rel_pagesVersionsHasOnePages,
- *   rel_pagesHasManyVersions,
- *   authUsers,
- *   authAccounts,
- *   authVerifications,
- *   authSessions
+ *   pagesShadow,
+ *   rel_pagesShadowHasOnePages,
+ *   rel_pagesHasManyShadow
  * }
  *
  * declare module 'rimecms' {
@@ -197,30 +205,19 @@ export declare const templateAPIKey = "\nexport const apikey = sqliteTable(\"api
  * export default schema
  * ```
  */
-export declare const templateExportSchema: ({ enumTables, enumRelations }: TemplateExportSchemaArgs) => string;
+export declare const templateExportSchema: ({ enumTables }: TemplateExportSchemaArgs) => string;
 /**
  * Generates a section header for a collection or area in the schema
  * Creates a visual separator with the slug name
  */
 export declare const templateHead: (slug: string) => string;
-export declare const templateDirectories: (slug: string) => string;
-type RelationOneArgs = {
-    name: string;
-    table: string;
-    parent: string;
-};
-type RelationManyArgs = {
-    name: string;
-    table: string;
-    many: string[];
-};
 type FieldsRelationTableArgs = {
     table: string;
+    junctionTable: string;
     relations: string[];
     hasLocale?: boolean;
 };
 type TemplateExportSchemaArgs = {
     enumTables: string[];
-    enumRelations: string[];
 };
 export {};