rimecms 0.22.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 bienbiendev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+![rime logo](https://github.com/bienbiendev/rime/blob/main/assets/logo-white.png#gh-dark-mode-only)
+![rime logo](https://github.com/bienbiendev/rime/blob/main/assets/logo-black.png#gh-light-mode-only)
+
+Headless CMS powered by SvelteKit.
+
+> [!NOTE]
+> Not ready for production
+
+![alt backend capture](https://github.com/bienbiendev/rime/blob/main/assets/preview.png?raw=true)
+
+[Documentation (in progress)](https://github.com/bienbiendev/rime-doc/tree/master/docs)
+
+## Features
+
+- Easy configuration
+- TypeScript
+- Built-in authentication (better-auth)
+- Auto-generated:
+  - API endpoints
+  - Types
+  - Database schema
+  - Admin panel
+- SQLite database (drizzle)
+- Live Edit system
+- Media management
+- Fine grained access control
+- i18n support
+- Document Hooks
+- Optional SMTP integration
+
+### Content Management
+
+Fields types:
+- Blocks
+- Tree (nested array)
+- Tabs
+- Rich Text (TipTap)
+- Relation
+- Link
+- Slug
+- Email
+- Group
+- Select/Radio/Checkbox
+- Number
+- And more...
+
+## Quick Start
+
+### 1. Create a SvelteKit Project
+
+```bash
+npx sv create my-app
+cd my-app
+```
+> [!NOTE]
+> Select TypeScript when prompted
+
+### 2. Install Rime
+
+```bash
+npm install rimecms
+npx rime init
+```
+
+The `rime init` command will automatically:
+
+- Create/populate `.env` file
+- Create `src/lib/+rime/rime.config.ts` config file
+- Create a `db/` folder
+- Add a `drizzle.config.ts`
+- Create `src/hooks.server.ts` with the required initialization code
+- Add the Rime plugin to `vite.config.ts`
+- Install dependencies.
+- Push initial schema
+
+> [!NOTE]
+> Please check that these files have been properly configured:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { sveltekit } from '@sveltejs/kit/vite';
+import { rime } from 'rimecms/vite';
+
+export default defineConfig({
+  plugins: [rime(), sveltekit()]
+});
+```
+
+```typescript
+// src/hooks.server.ts (should be created)
+import config from '$lib/+rime.generated/rime.config.server.js';
+import { handlers } from 'rimecms';
+import { sequence } from '@sveltejs/kit/hooks';
+
+export const handle = sequence(...(await handlers(config)));
+```
+
+```
+#.env
+BETTER_AUTH_SECRET=super_secret
+PUBLIC_RIME_URL=http://localhost:5173
+
+RIME_LOG_TO_FILE=true
+RIME_LOG_LEVEL=DEBUG
+
+# RIME_CACHE_ENABLED=false
+# RIME_SMTP_USER=user@mail.com
+# RIME_SMTP_PASSWORD=supersecret
+# RIME_SMTP_HOST=smtphost.com
+# RIME_SMTP_PORT=465
+```
+
+### 3. Create the first admin user
+
+```bash
+npm run dev
+```
+
+```bash
+curl -v POST http://localhost:5173/api/init \
+  -H "Content-Type: application/json" \
+  -d '{"email": "you@website.com", "password": "super-Secret+2000", "name": "Admin"}'
+```
+
+## Configuration Example
+
+```typescript
+// ./src/lib/+rime/rime.config.ts
+import { rime, Collection, Area } from '$rime/config';
+import { adapterSqlite } from 'rimecms/sqlite';
+import { Settings2 } from '@lucide/svelte';
+import { relation, link, richText, text, toggle } from 'rimecms/fields';
+import { access } from "rimecms/util";
+
+const Pages = Collection.create('pages', {
+  fields: [
+    text('title').isTitle().required(),
+    relation('parent').to('pages'),
+    richText('intro')
+  ],
+  access: {
+    read: () => true,
+    create: (user) => access.isAdmin(user),
+    update: (user) => access.hasRoles(user, 'admin', 'editor')
+  }
+};
+
+const Settings = Area.create('settings', {
+  icon: Settings2,
+  fields: [
+    toggle('maintenance'),
+    link('about'),
+    relation('logo').to('medias')
+  ],
+  access: {
+    read: () => true
+  }
+};
+
+const Medias = Collection.create('medias', {
+  label: {
+    singular: 'Media',
+    plural: 'Medias',
+  },
+  upload: true,
+  fields: [
+    text('alt')
+  ]
+};
+
+// Properties prefixed with "$" are server-only props, they will be stripped
+// in the generated client config
+export default rime({
+  $adapter: adapterSqlite('my-db.sqlite'),
+  collections: [Pages, Medias],
+  areas: [Settings],
+  staff: {
+    roles: [{ value: 'admin', label: 'Administrator' }, { value: 'editor' }],
+    fields: [
+      text('website')
+    ]
+  },
+  panel: {
+    $access: (user) => access.hasRoles(user, 'admin', 'editor'),
+  }
+});
+
+```
+
+> [!NOTE]
+> Icons must be imported from `@lucide/svelte` (other icon packages are not tested, but should work if a size prop is available on icon component)
+> Detailed configuration documentation is in development. Feel free to open issues for questions!
+
+## Retrieve your data
+
+### In routes handlers :
+
+```ts
+export const load = async (event: LayoutServerLoadEvent) => {
+  const { rime } = event.locals;
+  // Get an Area document
+  const menu = await rime.area('menu').find();
+  // Get all pages documents
+  const pages = await rime.collection('pages').findAll({ locale: 'en' });
+  // Get a page byId
+  const home = await rime.collection('pages').findById({ locale: 'en', id: 'some-id' });
+  // Get a user with a query
+  const [user] = await rime.collection('users').find({
+    query: `where[email][equals]=some@email.com` // qs query or ParsedQsQuery
+  });
+  // Get some config values
+  const languages = rime.config.getLocalesCodes();
+  const collections = rime.config.collections;
+  //...
+};
+```
+
+### From the API :
+```ts
+const { docs } = await fetch('http://localhost:5173/api/pages').then(r => r.json())
+const { docs } = await fetch('http://localhost:5173/api/pages?sort=title&limit=1').then(r => r.json())
+const { docs } = await fetch('http://localhost:5173/api/pages?where[author][like]=some-id&locale=en`;').then(r => r.json())
+```
+
+## DEPLOYING
+
+For now I am using it with @svelte/adapter-node, other adapter not tested and probably not working.
+
+With the node adapter :
+```sh
+npx rime build
+npx rime build -d # to copy the database directory
+```
+It's doing bascically `vite build` under the hood and create the polka server file inside an app directory, plus giving some info on how to run it.
+
+## ROADMAP
+
+- [x] switch from lucia to better-auth
+- [x] Document locked while being edited by another user
+- [x] Panel i18n
+- [x] Document status
+- [x] Tree field
+- [x] more tiptap integration
+- [x] more flexible better-auth integration
+- [x] Document version
+- [x] collection nested
+- [x] more better-auth integration
+- [~] Documentation
+- [ ] Live Edit system in practice
+- [ ] auto-saved draft
+- [ ] Put bin commands in a separate package ex: @rime/kit
+- [ ] configurable medias/config path
+
+## Acknowledgments
+
+- Built with components from @huntabyte's bits-ui
+- Inspired by Kirby CMS and Payload CMS architectures

package/dist/adapter-sqlite/area.d.ts

@@ -0,0 +1,48 @@
+import { VERSIONS_OPERATIONS } from '../core/collections/versions/operations.js';
+import type { Config } from '../core/config/types.js';
+import type { ConfigContext } from '../core/rime.server.js';
+import type { AreaSlug, GenericDoc, RawDoc } from '../core/types/doc.js';
+import type { GetRegisterType } from '../index.js';
+import type { DeepPartial } from '../util/types.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+/**
+ * Creates an area facade for SQLite adapter operations with CRUD functionality.
+ * Handles both versioned and non-versioned areas with support for localization.
+ */
+declare const createAreaFacade: <const C extends Config>(args: {
+    db: LibSQLDatabase<GetRegisterType<"Schema">>;
+    tables: any;
+    configCtx: ConfigContext<C>;
+}) => {
+    update: Update;
+    createArea: (slug: AreaSlug, values: Partial<GenericDoc>, locale?: string) => Promise<{
+        id: string;
+        versionId: string;
+    } | undefined>;
+    get: Get;
+};
+export default createAreaFacade;
+/****************************************************/
+type Get = (args: {
+    slug: AreaSlug;
+    locale?: string;
+    depth?: number;
+    select?: string[];
+    /** Optional parameter to get a specific version */
+    versionId?: string;
+    /** Optional parameter if versionId is not defined and draft=true
+     * 	it will get the latest doc no matter its status
+     * 	else the published document will be retrieved
+     */
+    draft?: boolean;
+}) => Promise<RawDoc>;
+type Update = (args: {
+    slug: AreaSlug;
+    data: DeepPartial<GenericDoc>;
+    locale?: string;
+    /** Optional parameter to specify direct version update */
+    versionId?: string;
+    versionOperation: (typeof VERSIONS_OPERATIONS)[keyof typeof VERSIONS_OPERATIONS];
+}) => Promise<{
+    id: string;
+}>;

package/dist/adapter-sqlite/area.js

@@ -0,0 +1,320 @@
+import { getRequestEvent } from '$app/server';
+import { VERSIONS_OPERATIONS, VersionOperations } from '../core/collections/versions/operations.js';
+import { VERSIONS_STATUS } from '../core/constant.js';
+import { RimeError } from '../core/errors/index.js';
+import { withLocalesSuffix, withVersionsSuffix } from '../core/naming.js';
+import { createBlankDocument } from '../util/doc.js';
+import { eq } from 'drizzle-orm';
+import * as adapterUtil from './util.js';
+import { buildWithParam } from './with.js';
+/**
+ * Creates an area facade for SQLite adapter operations with CRUD functionality.
+ * Handles both versioned and non-versioned areas with support for localization.
+ */
+const createAreaFacade = (args) => {
+    const { db, tables, configCtx } = args;
+    /**
+     * Retrieves an area document. If the area doesn't exist, it creates a blank one.
+     * For versioned areas, returns either a specific version (if versionId is provided)
+     * or the latest/published version.
+     */
+    const get = async ({ slug, locale, select, versionId, draft }) => {
+        const areaConfig = configCtx.areas[slug];
+        if (!areaConfig) {
+            throw new RimeError(RimeError.INIT, slug + ' is not an area, should never happen');
+        }
+        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);
+            if (!doc) {
+                await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
+                // @ts-expect-error slug is a tableName
+                doc = await db.query[slug].findFirst(params);
+            }
+            if (!doc) {
+                throw new Error('Database error');
+            }
+            return doc;
+        }
+        else {
+            // First check for record presence
+            // @ts-expect-error slug is a tableName
+            const area = await db.query[slug].findFirst({ id: true });
+            // If no area exists yet, create it
+            if (!area) {
+                await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
+            }
+            // Implementation for versioned areas
+            const versionsTable = withVersionsSuffix(slug);
+            const withParam = buildWithParam({
+                slug: versionsTable,
+                select,
+                locale,
+                tables,
+                config: areaConfig
+            });
+            // Handle select columns for version table
+            const versionSelectColumns = adapterUtil.columnsParams({
+                table: tables[versionsTable],
+                select
+            });
+            // Handle select columns for root table
+            const rootSelectColumns = adapterUtil.columnsParams({ table: tables[slug], select });
+            // Configure the query based on whether we want a specific version or the latest
+            // For the "save in a new draft" action we need to get the published version
+            let params;
+            if (versionId) {
+                // If versionId is provided, get that specific version
+                params = {
+                    columns: rootSelectColumns,
+                    with: {
+                        [versionsTable]: {
+                            columns: versionSelectColumns,
+                            with: withParam,
+                            where: eq(tables[versionsTable].id, versionId)
+                        }
+                    }
+                };
+            }
+            else {
+                // get the latest
+                params = {
+                    columns: rootSelectColumns,
+                    with: {
+                        [versionsTable]: {
+                            columns: versionSelectColumns,
+                            with: withParam,
+                            ...adapterUtil.buildPublishedOrLatestVersionParams({
+                                draft,
+                                config: areaConfig,
+                                table: tables[versionsTable]
+                            })
+                        }
+                    }
+                };
+            }
+            // @ts-expect-error slug is a tableName
+            const doc = await db.query[slug].findFirst(params);
+            if (!doc) {
+                throw new RimeError(RimeError.OPERATION_ERROR);
+            }
+            return adapterUtil.mergeRawDocumentWithVersion(doc, versionsTable, select);
+        }
+    };
+    /**
+     * Creates a new area document. For versioned areas, creates both
+     * the root document and its first version. For non-versioned areas,
+     * creates a single document with the provided data.
+     *
+     * @example
+     * // Create a new area
+     * await createArea(
+     *   'settings',
+     *   { theme: 'light', notifications: true },
+     *   'en'
+     * );
+     *
+     * @returns For versioned areas, returns object with id and versionId
+     */
+    const createArea = async (slug, values, locale) => {
+        const now = new Date();
+        const config = configCtx.areas[slug];
+        const hasVersions = !!config.versions;
+        if (hasVersions) {
+            // Create root document first
+            const docId = await adapterUtil.insertTableRecord(db, tables, slug, {
+                createdAt: now,
+                updatedAt: now
+            });
+            // Generate version ID
+            const versionsTableName = withVersionsSuffix(slug);
+            // Prepare data for versions table
+            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(values, {
+                tables,
+                mainTableName: versionsTableName,
+                localesTableName: withLocalesSuffix(versionsTableName),
+                locale,
+                fillNotNull: true
+            });
+            if (config.versions && config.versions.draft) {
+                mainData.status = 'published';
+            }
+            // Insert version record
+            const versionId = await adapterUtil.insertTableRecord(db, tables, versionsTableName, {
+                ownerId: docId,
+                ...mainData,
+                createdAt: now,
+                updatedAt: now
+            });
+            // Insert localized data if needed
+            if (isLocalized && Object.keys(localizedData).length) {
+                await adapterUtil.insertTableRecord(db, tables, withLocalesSuffix(versionsTableName), {
+                    ...localizedData,
+                    ownerId: versionId,
+                    locale: locale
+                });
+            }
+            // Return both IDs for versioned collections
+            return {
+                id: docId,
+                versionId
+            };
+        }
+        else {
+            const tableLocales = withLocalesSuffix(slug);
+            // Prepare data for insertion using the shared utility function
+            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(values, {
+                tables,
+                mainTableName: slug,
+                localesTableName: tableLocales,
+                locale,
+                fillNotNull: true
+            });
+            // Insert main record
+            const createId = await adapterUtil.insertTableRecord(db, tables, slug, {
+                ...mainData
+            });
+            // Insert localized data if needed
+            if (isLocalized) {
+                await adapterUtil.insertTableRecord(db, tables, tableLocales, {
+                    ...localizedData,
+                    ownerId: createId,
+                    locale
+                });
+            }
+        }
+    };
+    /**
+     * Updates an area document using different versioning strategies.
+     * Supports multiple update patterns:
+     * - Simple update for non-versioned areas
+     * - Direct version update for versioned areas
+     * - Creating new versions from existing ones
+     * - Publishing draft versions
+     *
+     * @example
+     * // Update a non-versioned area
+     * const { id, versionId } = await update({
+     *   slug: 'settings',
+     *   data: { theme: 'dark' },
+     *   versionOperation: VERSIONS_OPERATIONS.UPDATE
+     * });
+     *
+     * // Update a specific version
+     * const { id, versionId } = await update({
+     *   slug: 'site-info',
+     *   data: { title: 'Updated Title' },
+     *   versionId: 'v456',
+     *   versionOperation: VERSIONS_OPERATIONS.UPDATE_VERSION
+     * });
+     *
+     * // Create a new draft from published version
+     * const { id, versionId } = await update({
+     *   slug: 'settings',
+     *   data: { theme: 'system' },
+     *   versionOperation: VERSIONS_OPERATIONS.NEW_DRAFT_FROM_PUBLISHED
+     * });
+     *
+     * @returns Object containing the IDs of the updated area and version
+     * @throws RimeError when operation fails or version ID is missing when required
+     */
+    const update = async ({ slug, data, locale, versionId, versionOperation }) => {
+        const now = new Date();
+        const areaConfig = configCtx.areas[slug];
+        const rows = await db.select({ id: tables[slug].id }).from(tables[slug]);
+        const area = rows[0];
+        // Simple update for non-versioned areas
+        if (VersionOperations.isSimpleUpdate(versionOperation)) {
+            // Original implementation for non-versioned areas
+            const keyTableLocales = withLocalesSuffix(slug);
+            // Prepare data for update using the shared utility function
+            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(data, {
+                tables,
+                mainTableName: slug,
+                localesTableName: keyTableLocales,
+                locale
+            });
+            // Update main table
+            await adapterUtil.updateTableRecord(db, tables, slug, {
+                recordId: area.id,
+                data: { ...mainData, updatedAt: now }
+            });
+            // Update localized data if needed
+            if (isLocalized) {
+                await adapterUtil.upsertLocalizedData(db, tables, keyTableLocales, {
+                    ownerId: area.id,
+                    data: localizedData,
+                    locale: locale
+                });
+            }
+            // For non-versioned areas, versionId is the same as id
+            return { id: area.id };
+        }
+        else if (VersionOperations.isSpecificVersionUpdate(versionOperation)) {
+            // Scenario 1: Update a specific version directly
+            if (!versionId) {
+                throw new RimeError(RimeError.OPERATION_ERROR, 'missing versionId @adapter-update-area');
+            }
+            // First, update the root table's updatedAt
+            await db
+                .update(tables[slug])
+                .set({
+                updatedAt: now
+            })
+                .where(eq(tables[slug].id, area.id));
+            const versionsTable = withVersionsSuffix(slug);
+            const versionsLocalesTable = withLocalesSuffix(versionsTable);
+            // Prepare data for update using the shared utility function
+            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(data, {
+                tables,
+                mainTableName: versionsTable,
+                localesTableName: versionsLocalesTable,
+                locale
+            });
+            // if draft is enabled on the collection
+            if (areaConfig.versions && areaConfig.versions.draft && mainData.status === 'published') {
+                // update all rows first to draft
+                await db.update(tables[versionsTable]).set({ status: VERSIONS_STATUS.DRAFT });
+            }
+            // Update version directly
+            await adapterUtil.updateTableRecord(db, tables, versionsTable, {
+                recordId: versionId,
+                data: { ...mainData, updatedAt: now }
+            });
+            // Update localized data if needed
+            if (isLocalized) {
+                await adapterUtil.upsertLocalizedData(db, tables, versionsLocalesTable, {
+                    ownerId: versionId,
+                    data: localizedData,
+                    locale: locale
+                });
+            }
+            return { id: area.id };
+        }
+        else if (VersionOperations.isNewVersionCreation(versionOperation)) {
+            // Scenario 2: version creation, update only main table
+            // the creation is handled by the caller update operation
+            await db
+                .update(tables[slug])
+                .set({
+                updatedAt: now
+            })
+                .where(eq(tables[slug].id, area.id));
+            return { id: area.id };
+        }
+        else {
+            throw new RimeError(RimeError.OPERATION_ERROR, 'Unhandled version operation');
+        }
+    };
+    return {
+        update,
+        createArea,
+        get
+    };
+};
+export default createAreaFacade;

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

@@ -0,0 +1,27 @@
+import type { User } from '../core/collections/auth/types.js';
+import type { CollectionSlug } from '../core/types/doc.js';
+import type { GetRegisterType } from '../index.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+/**
+ * Creates and configures the authentication facade for the SQLite adapter
+ * @param args Configuration parameters for the auth facade
+ * @returns Object containing all auth-related functions
+ */
+declare const createAuthFacade: (args: {
+    db: LibSQLDatabase<GetRegisterType<"Schema">>;
+    schema: GetRegisterType<"Schema">;
+}) => {
+    betterAuthAdapter: (options: import("better-auth/*").BetterAuthOptions) => import("better-auth/*").Adapter;
+    hasAuthUser: () => Promise<boolean>;
+    getAuthUserId: ({ slug, id }: {
+        slug: CollectionSlug;
+        id: string;
+    }) => Promise<any>;
+    getUserAttributes: ({ authUserId, slug }: GetUserAttributesArgs) => Promise<User | undefined>;
+    isSuperAdmin: (userId: string) => Promise<boolean>;
+};
+export default createAuthFacade;
+type GetUserAttributesArgs = {
+    authUserId: string;
+    slug: CollectionSlug;
+};