rimecms 0.22.0

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

@@ -0,0 +1,190 @@
+import { withDirectoriesSuffix, withVersionsSuffix } from '../../core/naming.js';
+import { date } from '../../fields/date/index.js';
+import { getFieldPrivateModule } from '../../fields/index.server.js';
+import { toCamelCase, toPascalCase, toSnakeCase } from '../../util/string.js';
+import { generateRelationshipDefinitions } from './relations/definition.server.js';
+import { generateJunctionTableDefinition } from './relations/junction.server.js';
+import buildRootTable from './root.server.js';
+import { templateAPIKey, templateAuth, templateDirectories, templateExportRelationsFieldsToTable, templateExportSchema, templateExportTables, templateHead, templateImports, templateRelationMany, templateRelationOne, templateTable } from './templates.server.js';
+import write from './write.server.js';
+export async function generateSchemaString(config) {
+    const collections = (config.collections || []).filter((c) => c._generateSchema !== false);
+    const areas = (config.areas || []).filter((a) => a._generateSchema !== false);
+    const schema = [templateImports];
+    let enumTables = [];
+    let enumRelations = [];
+    let relationFieldsExportDic = {};
+    const blocksRegister = [];
+    for (const collection of collections) {
+        const collectionSlug = toCamelCase(collection.slug);
+        let rootTableName = collectionSlug;
+        let versionsRelationsDefinitions = [];
+        schema.push(templateHead(collectionSlug));
+        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
+            // 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;
+            // 1. Process root table
+            // 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 rootFields = [...rootFieldsFromConfig, ...baseRootFields];
+            // Buiuld the main root buildRootTable with only _root fields and created/updatedAt
+            const { schema: rootCollectionSchema } = await buildRootTable({
+                blocksRegister: [],
+                fields: rootFields,
+                rootName: rootTableName,
+                locales: [],
+                hasAuth: !!collection.auth,
+                versionsFrom: false,
+                tableName: rootTableName
+            });
+            // Ad the root table to the schema
+            schema.push(rootCollectionSchema);
+            // 2. Handle versions table rename and relation root <-> root_verions definition
+            // overwrite the collection name with the _versions one to generate all table
+            // eg. blocks, relation related to the _versions one
+            rootTableName = withVersionsSuffix(collectionSlug);
+            // Filter fields that should be processed, remove the _root ones
+            collection.fields = collection.fields.filter(isNotRootField);
+            // create specific relations between root <-> root_verions
+            const manyVersionsToOneName = `rel_${rootTableName}HasOne${toPascalCase(collectionSlug)}`;
+            const oneToManyVersionsName = `rel_${collectionSlug}HasMany${toPascalCase(rootTableName)}`;
+            versionsRelationsDefinitions = [
+                templateRelationOne({
+                    name: manyVersionsToOneName,
+                    table: rootTableName,
+                    parent: collectionSlug
+                }),
+                templateRelationMany({
+                    name: oneToManyVersionsName,
+                    table: collectionSlug,
+                    many: [rootTableName]
+                })
+            ];
+            // add the root table to :
+            // export tables = { ... }
+            enumTables = [...enumTables, collectionSlug];
+            // add the root <-> root_versions relations to :
+            // export schema = { ... }
+            enumRelations = [...enumRelations, manyVersionsToOneName, oneToManyVersionsName];
+        }
+        const { schema: collectionSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale } = await buildRootTable({
+            blocksRegister,
+            fields: collection.fields,
+            rootName: rootTableName,
+            locales: config.localization?.locales || [],
+            hasAuth: !!collection.auth,
+            versionsFrom: collection.versions ? collectionSlug : false,
+            tableName: rootTableName
+        });
+        const { junctionTable, junctionTableName } = generateJunctionTableDefinition({
+            tableName: rootTableName,
+            relationFieldsMap,
+            hasLocale: relationFieldsHasLocale
+        });
+        if (junctionTable.length) {
+            relationsDic[rootTableName] ??= [];
+            relationsDic[rootTableName].push(junctionTableName);
+        }
+        const { relationsDefinitions, relationsNames } = generateRelationshipDefinitions({
+            relationsDic
+        });
+        const relationsTableNames = Object.values(relationsDic).flat();
+        enumTables = Array.from(new Set([...enumTables, rootTableName, ...relationsTableNames]));
+        enumRelations = [...enumRelations, ...relationsNames];
+        relationFieldsExportDic = {
+            ...relationFieldsExportDic,
+            [rootTableName]: relationFieldsMap
+        };
+        if (collection.upload) {
+            schema.push(templateDirectories(collection.slug));
+            enumTables = [...enumTables, withDirectoriesSuffix(collection.slug)];
+        }
+        schema.push(collectionSchema, junctionTable, ...versionsRelationsDefinitions, relationsDefinitions);
+    }
+    /**
+     * Areas
+     */
+    for (const area of areas) {
+        const areaSlug = toCamelCase(area.slug);
+        let rootTableName = toSnakeCase(areaSlug);
+        let versionsRelationsDefinitions = [];
+        schema.push(templateHead(areaSlug));
+        if (area.versions) {
+            // For now, areas don't need to filter out fields with or without _root
+            // as these fields would have no effect
+            // Overrite
+            rootTableName = withVersionsSuffix(areaSlug);
+            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')));
+            versionsRelationsDefinitions = [
+                templateRelationOne({
+                    name: manyVersionsToOneName,
+                    table: rootTableName,
+                    parent: areaSlug
+                }),
+                templateRelationMany({
+                    name: oneToManyVersionsName,
+                    table: areaSlug,
+                    many: [rootTableName]
+                })
+            ];
+            enumTables = [...enumTables, areaSlug];
+            enumRelations = [...enumRelations, manyVersionsToOneName, oneToManyVersionsName];
+        }
+        const { schema: areaSchema, relationsDic, relationFieldsMap, relationFieldsHasLocale } = await buildRootTable({
+            blocksRegister,
+            fields: area.fields,
+            rootName: rootTableName,
+            locales: config.localization?.locales || [],
+            tableName: rootTableName,
+            versionsFrom: area.versions ? areaSlug : false
+        });
+        const { junctionTable, junctionTableName } = generateJunctionTableDefinition({
+            tableName: rootTableName,
+            relationFieldsMap,
+            hasLocale: relationFieldsHasLocale
+        });
+        if (junctionTable.length) {
+            relationsDic[rootTableName] ??= [];
+            relationsDic[rootTableName].push(junctionTableName);
+        }
+        const { relationsDefinitions, relationsNames } = generateRelationshipDefinitions({
+            relationsDic
+        });
+        const relationsTableNames = Array.from(new Set(Object.values(relationsDic).flat()));
+        enumTables = [...enumTables, rootTableName, ...relationsTableNames];
+        enumRelations = [...enumRelations, ...relationsNames];
+        relationFieldsExportDic = {
+            ...relationFieldsExportDic,
+            [rootTableName]: relationFieldsMap
+        };
+        schema.push(areaSchema, junctionTable, ...versionsRelationsDefinitions, relationsDefinitions);
+    }
+    const HAS_API_KEY = collections.filter((c) => c.auth?.type === 'apiKey').length;
+    schema.push(templateAuth);
+    if (HAS_API_KEY) {
+        schema.push(templateAPIKey);
+        enumTables.push('apikey');
+    }
+    schema.push(templateExportTables(enumTables));
+    schema.push(templateExportRelationsFieldsToTable(relationFieldsExportDic));
+    schema.push(templateExportSchema({ enumTables, enumRelations }));
+    return schema.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+const generateSchema = async (config) => {
+    const result = await generateSchemaString(config);
+    write(result);
+};
+export default generateSchema;

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

@@ -0,0 +1,55 @@
+/**
+ * Generates Drizzle ORM relationship definitions from a relations dictionary
+ * Creates both one-to-many and many-to-one relationship definitions by:
+ * - Converting each entry into 'hasOne' relations (parent -> child)
+ * - Creating 'hasMany' relations for reverse relationships (child -> parent)
+ *
+ * @example
+ * const relationsDic = { pages: ['users', 'medias'] }
+ *
+ * output:
+ * {
+ *   relationsDefinitions: `
+ *     export const rel_usersHasOnePages = relations(users, ({ one }) => ({
+ *       pages: one(pages, {
+ *         fields: [users.ownerId],
+ *         references: [pages.id],
+ *       })
+ *     }))
+ *
+ *     export const rel_pagesHasMany = relations(pages, ({ many }) => ({
+ *       users: many(users),
+ *     }))`,
+ *   relationsNames: ['rel_usersHasOnePages', 'rel_pagesHasMany']
+ * }
+ */
+export declare function generateRelationshipDefinitions({ relationsDic }: Args): Return;
+type Return = {
+    /**
+     * @example
+     * export const rel_usersHasOnePages = relations(users, ({ one }) => ({
+     *   pages : one(pages, {
+     *     fields: [users.ownerId],
+     *     references: [pages.id],
+     *   }),
+     * }))
+     *
+     * export const rel_pagesHasMany = relations(pages, ({ many }) => ({
+     *   users: many(users),
+     * }))
+     */
+    relationsDefinitions: string;
+    /**
+     * @example
+     * [ 'rel_mediasHasOnePages', 'rel_usersHasOnePages', 'rel_pagesHasMany' ]
+     */
+    relationsNames: string[];
+};
+type Args = {
+    relationsDic: Record<string, string[]>;
+};
+export type RelationFieldsMap = Record<string, {
+    to: string;
+    localized?: boolean;
+}>;
+export {};

package/dist/adapter-sqlite/generate-schema/relations/definition.server.js

@@ -0,0 +1,52 @@
+import { toPascalCase } from '../../../util/string.js';
+import { templateRelationMany, templateRelationOne } from '../templates.server.js';
+const p = toPascalCase;
+/**
+ * Generates Drizzle ORM relationship definitions from a relations dictionary
+ * Creates both one-to-many and many-to-one relationship definitions by:
+ * - Converting each entry into 'hasOne' relations (parent -> child)
+ * - Creating 'hasMany' relations for reverse relationships (child -> parent)
+ *
+ * @example
+ * const relationsDic = { pages: ['users', 'medias'] }
+ *
+ * output:
+ * {
+ *   relationsDefinitions: `
+ *     export const rel_usersHasOnePages = relations(users, ({ one }) => ({
+ *       pages: one(pages, {
+ *         fields: [users.ownerId],
+ *         references: [pages.id],
+ *       })
+ *     }))
+ *
+ *     export const rel_pagesHasMany = relations(pages, ({ many }) => ({
+ *       users: many(users),
+ *     }))`,
+ *   relationsNames: ['rel_usersHasOnePages', 'rel_pagesHasMany']
+ * }
+ */
+export function generateRelationshipDefinitions({ relationsDic }) {
+    if (Object.keys(relationsDic).length === 0)
+        return { relationsDefinitions: '', relationsNames: [] };
+    const relationsNames = [];
+    let toOnes = [];
+    const toManies = [];
+    for (const [table, many] of Object.entries(relationsDic)) {
+        toOnes = [
+            ...toOnes,
+            ...many.map((t) => {
+                const name = `rel_${t}HasOne${p(table)}`;
+                relationsNames.push(name);
+                return templateRelationOne({ name, table: t, parent: table });
+            })
+        ];
+        const name = `rel_${table}HasMany`;
+        relationsNames.push(name);
+        toManies.push(templateRelationMany({ name, table, many }));
+    }
+    return {
+        relationsDefinitions: [...toOnes, ...toManies].join('\n\n'),
+        relationsNames
+    };
+}

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

@@ -0,0 +1,31 @@
+import type { RelationFieldsMap } from './definition.server.js';
+/**
+ * Generates a junction table definition for many-to-many relationships
+ * Takes a table name, its relation fields mapping, and locale flag to create:
+ * - A junction table (e.g., 'pagesRels') with references to related tables
+ *
+ * @example
+ * {
+ *   junctionTable: `
+ *     export const pagesRels = sqliteTable('pages_rels', {
+ *       id: pk(),
+ *       path: text('path'),
+ *       position: integer('position'),
+ *       ownerId: text('owner_id').references(() => pages.id, { onDelete: 'cascade' }),
+ *       mediasId: text('media_id').references(() => medias.id, { onDelete: 'cascade' }),
+ *       locale: text('locale')
+ *     })`,
+ *   junctionTableName: 'pagesRels'
+ * }
+ */
+export declare function generateJunctionTableDefinition(args: Args): Return;
+type Args = {
+    tableName: string;
+    relationFieldsMap: RelationFieldsMap;
+    hasLocale: boolean;
+};
+type Return = {
+    junctionTable: string;
+    junctionTableName: string;
+};
+export {};

package/dist/adapter-sqlite/generate-schema/relations/junction.server.js

@@ -0,0 +1,36 @@
+import { templateRelationFieldsTable, templateRelationMany } from '../templates.server.js';
+/**
+ * Generates a junction table definition for many-to-many relationships
+ * Takes a table name, its relation fields mapping, and locale flag to create:
+ * - A junction table (e.g., 'pagesRels') with references to related tables
+ *
+ * @example
+ * {
+ *   junctionTable: `
+ *     export const pagesRels = sqliteTable('pages_rels', {
+ *       id: pk(),
+ *       path: text('path'),
+ *       position: integer('position'),
+ *       ownerId: text('owner_id').references(() => pages.id, { onDelete: 'cascade' }),
+ *       mediasId: text('media_id').references(() => medias.id, { onDelete: 'cascade' }),
+ *       locale: text('locale')
+ *     })`,
+ *   junctionTableName: 'pagesRels'
+ * }
+ */
+export function generateJunctionTableDefinition(args) {
+    const { tableName, relationFieldsMap, hasLocale } = args;
+    let junctionTable = '';
+    const relationName = `rel_${tableName}Rels`;
+    const tablesRelationsTo = [...new Set(Object.values(relationFieldsMap).map((r) => r.to))];
+    if (tablesRelationsTo.length) {
+        junctionTable = [
+            templateRelationFieldsTable({ table: tableName, relations: tablesRelationsTo, hasLocale }),
+            templateRelationMany({ name: relationName, table: tableName, many: tablesRelationsTo })
+        ].join('\n');
+    }
+    return {
+        junctionTable,
+        junctionTableName: `${tableName}Rels`
+    };
+}

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

@@ -0,0 +1,24 @@
+import type { LocaleConfig } from '../../core/config/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';
+type Args = {
+    fields: FieldBuilder<Field>[];
+    tableName: string;
+    rootName: string;
+    locales?: LocaleConfig[];
+    hasParent?: boolean;
+    relationFieldsMap?: RelationFieldsMap;
+    relationsDic?: Record<string, string[]>;
+    hasAuth?: boolean;
+    versionsFrom?: string | false;
+    blocksRegister: string[];
+};
+type Return = {
+    schema: string;
+    relationFieldsMap: RelationFieldsMap;
+    relationsDic: Record<string, string[]>;
+    relationFieldsHasLocale: boolean;
+};
+declare const buildRootTable: ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap, relationsDic, hasAuth, versionsFrom, blocksRegister }: Args) => Promise<Return>;
+export default buildRootTable;

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

@@ -0,0 +1,196 @@
+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 { TreeBuilder } from '../../fields/tree/index.js';
+import { toPascalCase } from '../../util/string.js';
+import { templateHasAuth, templateLocale, templateParent, templateTable } from './templates.server.js';
+const p = toPascalCase;
+const buildRootTable = async ({ fields: incomingFields, tableName, rootName, hasParent, locales, relationFieldsMap = {}, relationsDic = {}, hasAuth, versionsFrom, blocksRegister }) => {
+    const blocksTables = [];
+    let relationFieldsHasLocale = false;
+    const generateFieldsTemplates = async (fields, withLocalized, parentPath = '') => {
+        let templates = [];
+        const checkLocalized = (field) => {
+            return ((withLocalized && field.raw.localized) ||
+                (!withLocalized && !field.raw.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);
+                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);
+                    templates = [...templates, ...tabFields];
+                }
+            }
+            else if (isRelationField(field.raw)) {
+                if (field.raw.localized) {
+                    relationFieldsHasLocale = true;
+                }
+                relationFieldsMap = {
+                    ...relationFieldsMap,
+                    [field.raw.name]: {
+                        to: field.raw.relationTo,
+                        localized: field.raw.localized
+                    }
+                };
+            }
+            else if (isBlocksField(field.raw)) {
+                for (const block of field.raw.blocks) {
+                    const blockTableName = `${rootName}Blocks${p(block.raw.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 } = await buildRootTable({
+                            blocksRegister,
+                            fields: block.raw.fields,
+                            tableName: blockTableName,
+                            hasParent: true,
+                            relationsDic,
+                            relationFieldsMap,
+                            locales,
+                            rootName
+                        });
+                        relationsDic = nestedRelationsDic;
+                        relationFieldsMap = nestedRelationFieldsDic;
+                        if (nestedRelationFieldsHasLocale)
+                            relationFieldsHasLocale = true;
+                        blocksRegister.push(blockTableName);
+                        blocksTables.push(blockTable);
+                    }
+                }
+            }
+            else if (field instanceof TreeBuilder) {
+                const treeTableName = `${rootName}Tree${p(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({
+                        blocksRegister,
+                        fields: field.raw.fields,
+                        tableName: treeTableName,
+                        hasParent: true,
+                        relationsDic,
+                        relationFieldsMap,
+                        locales,
+                        rootName
+                    });
+                    relationsDic = nestedRelationsDic;
+                    relationFieldsMap = nestedRelationFieldsDic;
+                    if (nestedRelationFieldsHasLocale)
+                        relationFieldsHasLocale = true;
+                    blocksRegister.push(treeTableName);
+                    blocksTables.push(treeTable);
+                }
+            }
+            else if (field instanceof FormFieldBuilder) {
+                if (checkLocalized(field)) {
+                    const serverField = await getFieldPrivateModule(field);
+                    if (serverField) {
+                        templates.push(serverField.toSchema(field, parentPath) + ',');
+                    }
+                }
+            }
+        }
+        return templates;
+    };
+    let table;
+    if (locales && locales.length && hasLocalizedField(incomingFields)) {
+        const tableNameLocales = withLocalesSuffix(tableName);
+        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 (hasAuth) {
+            strUnlocalizedFields.push(templateHasAuth(rootName));
+        }
+        table = templateTable(tableName, strUnlocalizedFields.join('\n  '));
+        table += templateTable(tableNameLocales, [...strLocalizedFields, templateLocale(), templateParent(tableName)].join('\n  '));
+    }
+    else {
+        const strFields = await generateFieldsTemplates(incomingFields);
+        if (hasParent) {
+            strFields.push(templateParent(rootName));
+        }
+        if (versionsFrom) {
+            strFields.push(templateParent(versionsFrom));
+        }
+        if (hasAuth) {
+            strFields.push(templateHasAuth(rootName));
+        }
+        table = templateTable(tableName, strFields.join('\n  '));
+    }
+    return {
+        schema: [table, ...blocksTables].join('\n\n'),
+        relationFieldsMap,
+        relationFieldsHasLocale,
+        relationsDic
+    };
+};
+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)) {
+                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)) {
+                    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)
+                return true;
+            for (const block of field.raw.blocks) {
+                if (hasLocalizedField(block.raw.fields)) {
+                    return true;
+                }
+            }
+        }
+        // Case 3: If it's a tree field, check all fields
+        else if (field instanceof TreeBuilder) {
+            if (field.raw.localized)
+                return true;
+            if (hasLocalizedField(field.raw.fields)) {
+                return true;
+            }
+        }
+        // Case 4: For regular form fields, check if it's marked as localized
+        else if (isFormField(field.raw) && field.raw.localized) {
+            return true;
+        }
+    }
+    // If no localized fields were found, return false
+    return false;
+}
+export default buildRootTable;