rimecms 0.22.0

package/dist/core/plugins/api-init/index.server.js

@@ -0,0 +1,79 @@
+import { dev } from '$app/environment';
+import { handleError } from '../../errors/handler.server.js';
+import { RimeError, RimeFormError } from '../../errors/index.js';
+import { extractData } from '../../operations/extract-data.server.js';
+import { trycatch, trycatchSync } from '../../../util/function.js';
+import { email as validateEmail, password as validatePassword } from '../../../util/validate.js';
+import { json } from '@sveltejs/kit';
+import { definePlugin } from '../index.js';
+export const apiInit = definePlugin(() => {
+    const requestHandler = async (event) => {
+        if (!dev)
+            throw new RimeError(RimeError.NOT_FOUND);
+        const hasAuthUser = await event.locals.rime.adapter.auth.hasAuthUser();
+        if (hasAuthUser || (!hasAuthUser && !dev)) {
+            throw handleError(new RimeError(RimeError.NOT_FOUND), { context: 'api' });
+        }
+        const data = await extractData(event.request);
+        const [error] = trycatchSync(() => validateForm(data));
+        if (error) {
+            throw handleError(error, {
+                context: 'action',
+                formData: { email: data.email }
+            });
+        }
+        event.locals.isInit = true;
+        const [signUpError] = await trycatch(() => event.locals.rime.auth.api.signUpEmail({
+            body: {
+                email: data.email,
+                name: data.name,
+                password: data.password,
+                type: 'staff'
+            }
+        }));
+        if (signUpError) {
+            throw handleError(signUpError, {
+                context: 'api',
+                formData: { email: data.email }
+            });
+        }
+        return json({ initialized: true });
+    };
+    return {
+        name: 'apiInit',
+        type: 'server',
+        routes: {
+            '/api/init': {
+                POST: requestHandler
+            }
+        }
+    };
+});
+const validateForm = (data) => {
+    const errors = {};
+    const { name, email, password } = data;
+    if (!email) {
+        errors.email = RimeFormError.REQUIRED_FIELD;
+    }
+    if (!name) {
+        errors.name = RimeFormError.REQUIRED_FIELD;
+    }
+    if (!password) {
+        errors.password = RimeFormError.REQUIRED_FIELD;
+    }
+    const emailValidation = validateEmail(email);
+    if (typeof emailValidation === 'string') {
+        errors.email = RimeFormError.INVALID_FIELD;
+    }
+    if (typeof name !== 'string') {
+        errors.name = RimeFormError.INVALID_FIELD;
+    }
+    const passwordValidation = validatePassword(password);
+    if (typeof passwordValidation === 'string') {
+        errors.name = RimeFormError.INVALID_FIELD;
+    }
+    if (Object.keys(errors).length > 0) {
+        throw new RimeFormError(errors);
+    }
+    return true;
+};

package/dist/core/plugins/cache/HeaderButton.svelte

@@ -0,0 +1,16 @@
+<script>
+	import { DatabaseZapIcon } from '@lucide/svelte';
+	import Button from '../../../panel/components/ui/button/button.svelte';
+	import { toast } from 'svelte-sonner';
+
+	const clearCache = async () => {
+		const res = await fetch('/api/clear-cache', { method: 'post' });
+		if (res.ok) {
+			toast.success('Cache cleared');
+		} else {
+			toast.error('An error occured clearing cache');
+		}
+	};
+</script>
+
+<Button variant="ghost" size="icon" icon={DatabaseZapIcon} onclick={clearCache}></Button>

package/dist/core/plugins/cache/HeaderButton.svelte.d.ts

@@ -0,0 +1,26 @@
+export default HeaderButton;
+type HeaderButton = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const HeaderButton: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/core/plugins/cache/cache.server.d.ts

@@ -0,0 +1,12 @@
+export declare class Cache {
+    private static memoryCache;
+    private static readonly MAX_MEMORY_ENTRIES;
+    private static getCacheStrategy;
+    static get<T>(key: string, loadData: () => Promise<T>): Promise<T>;
+    private static getFromMemory;
+    private static getFromDisk;
+    private static setMemoryCache;
+    private static setToDisk;
+    static delete(key: string): Promise<void>;
+    static clear(): void;
+}

package/dist/core/plugins/cache/cache.server.js

@@ -0,0 +1,97 @@
+import { getRequestEvent } from '$app/server';
+import { logger } from '../../logger/index.server.js';
+import fs from 'fs';
+import path from 'path';
+const cachePath = path.resolve(process.cwd(), '.cache');
+if (!fs.existsSync(cachePath)) {
+    fs.mkdirSync(cachePath);
+}
+const IS_ENV_CACHE_ENABLED = process.env.RIME_CACHE_ENABLED === 'true';
+export class Cache {
+    static memoryCache = new Map();
+    static MAX_MEMORY_ENTRIES = 1000;
+    static getCacheStrategy() {
+        const strategy = process.env.RIME_CACHE_STRATEGY?.toLowerCase();
+        return strategy === 'memory' || strategy === 'disk' ? strategy : 'memory';
+    }
+    static async get(key, loadData) {
+        const event = getRequestEvent();
+        if (!event.locals.cacheEnabled || !IS_ENV_CACHE_ENABLED) {
+            logger.debug(`Cache disabled, loading ${key}`);
+            return loadData();
+        }
+        const strategy = this.getCacheStrategy();
+        logger.debug(`Cache enabled, loading ${key} with the ${strategy} strategy`);
+        if (strategy === 'memory') {
+            return this.getFromMemory(key, loadData);
+        }
+        else {
+            return this.getFromDisk(key, loadData);
+        }
+    }
+    static async getFromMemory(key, loadData) {
+        // Check memory cache only
+        if (this.memoryCache.has(key)) {
+            return this.memoryCache.get(key);
+        }
+        // Load fresh data and cache in memory only
+        const freshData = await loadData();
+        this.setMemoryCache(key, freshData);
+        return freshData;
+    }
+    static async getFromDisk(key, loadData) {
+        // Check disk cache only
+        const keyPath = path.join(cachePath, key + '.txt');
+        try {
+            const data = await fs.promises.readFile(keyPath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                logger.error(err);
+            }
+        }
+        // Load fresh data and cache to disk only
+        const freshData = await loadData();
+        await this.setToDisk(key, JSON.stringify(freshData));
+        return freshData;
+    }
+    static setMemoryCache(key, value) {
+        // Simple LRU: remove oldest entry if at limit
+        if (this.memoryCache.size >= this.MAX_MEMORY_ENTRIES) {
+            const firstKey = this.memoryCache.keys().next().value;
+            if (firstKey) {
+                this.memoryCache.delete(firstKey);
+            }
+        }
+        this.memoryCache.set(key, value);
+    }
+    static async setToDisk(key, value) {
+        const keyPath = path.join(cachePath, key + '.txt');
+        await fs.promises.writeFile(keyPath, value);
+    }
+    static async delete(key) {
+        const strategy = this.getCacheStrategy();
+        if (strategy === 'memory') {
+            this.memoryCache.delete(key);
+        }
+        else {
+            const keyPath = path.join(cachePath, key + '.txt');
+            try {
+                await fs.promises.rm(keyPath);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    logger.error('Failed to delete cache file:', err);
+                }
+            }
+        }
+    }
+    static clear() {
+        this.memoryCache.clear();
+        if (fs.existsSync(cachePath)) {
+            fs.rmSync(cachePath, { recursive: true });
+            fs.mkdirSync(cachePath);
+        }
+    }
+}

package/dist/core/plugins/cache/handler.server.d.ts

@@ -0,0 +1,9 @@
+import type { Handle } from '@sveltejs/kit';
+export declare const handler: Handle;
+declare global {
+    namespace App {
+        interface Locals {
+            cacheEnabled: boolean;
+        }
+    }
+}

package/dist/core/plugins/cache/handler.server.js

@@ -0,0 +1,23 @@
+export const handler = async ({ event, resolve }) => {
+    const { rime } = event.locals;
+    event.locals.cacheEnabled = false;
+    // Only cache GET requests
+    if (event.request.method !== 'GET') {
+        return await resolve(event);
+    }
+    // Do not cache if env RIME_CACHE_ENABLED is not 'true'
+    if (!(process.env.RIME_CACHE_ENABLED === 'true')) {
+        return await resolve(event);
+    }
+    // Do not cache panel routes
+    if (event.url.pathname.startsWith('/panel')) {
+        return await resolve(event);
+    }
+    // Use configuration function
+    if (!rime.cache.isEnabled(event)) {
+        return await resolve(event);
+    }
+    event.locals.cacheEnabled = true;
+    event.setHeaders({ 'cache-control': 'max-age=3600' });
+    return await resolve(event);
+};

package/dist/core/plugins/cache/index.d.ts

@@ -0,0 +1,5 @@
+export declare const cacheClient: () => {
+    readonly name: "cache/client";
+    readonly type: "client";
+    readonly configure: <const C extends import("../../config/types.js").SanitizedConfigClient>(config: C) => C;
+};

package/dist/core/plugins/cache/index.js

@@ -0,0 +1,21 @@
+import { definePluginClient } from '../index.js';
+import HeaderButton from './HeaderButton.svelte';
+export const cacheClient = definePluginClient(() => {
+    return {
+        name: 'cache/client',
+        type: 'client',
+        configure: (config) => {
+            config = {
+                ...config,
+                panel: {
+                    ...(config.panel || {}),
+                    components: {
+                        ...(config.panel?.components || { header: [], collectionHeader: [] }),
+                        header: [...(config.panel?.components?.header || []), HeaderButton]
+                    }
+                }
+            };
+            return config;
+        }
+    };
+});

package/dist/core/plugins/cache/index.server.d.ts

@@ -0,0 +1,31 @@
+import { type RequestEvent, type RequestHandler } from '@sveltejs/kit';
+export type CacheActions = {
+    get: <T>(name: string, get: () => Promise<T>) => Promise<T>;
+    clear: () => ReturnType<RequestHandler>;
+    isEnabled: (event: RequestEvent) => boolean;
+    toHashKey: (...params: unknown[]) => string;
+    createKey: (namespace: string, params: Record<string, unknown>) => string;
+};
+type CacheOptions = {
+    /**
+     * A function that define if the API cache should be enabled.
+     * Only GET requests from non-panel routes are cached
+     *
+     * @example
+     * isEnabled: (event) => !event.locals.user // default
+     */
+    isEnabled?: (event: RequestEvent) => boolean;
+};
+export declare const cache: (options?: CacheOptions) => {
+    readonly name: "cache";
+    readonly type: "server";
+    readonly configure: <const C extends import("../../config/types.js").Config>(config: C) => C;
+    readonly routes: {
+        readonly '/api/clear-cache': {
+            readonly POST: () => Response;
+        };
+    };
+    readonly actions: CacheActions;
+    readonly handler: import("@sveltejs/kit").Handle;
+};
+export {};

package/dist/core/plugins/cache/index.server.js

@@ -0,0 +1,74 @@
+import { toHash } from '../../../util/string.js';
+import { json } from '@sveltejs/kit';
+import { definePlugin } from '../index.js';
+import { Cache } from './cache.server.js';
+import { handler } from './handler.server.js';
+import HeaderButton from './HeaderButton.svelte';
+export const cache = definePlugin((options) => {
+    //
+    async function getAction(key, get) {
+        return await Cache.get(key, get);
+    }
+    /**
+     * Empty the .cache folder
+     */
+    const clearCache = () => {
+        Cache.clear();
+        return json({ message: 'Cache cleared' });
+    };
+    /**
+     * Helper to convert any value to a string representation for cache keys
+     */
+    const toKey = (value) => {
+        if (value === undefined || value === null) {
+            return '0';
+        }
+        if (Array.isArray(value)) {
+            return value.map(toKey).join(',');
+        }
+        return String(value);
+    };
+    const actions = {
+        get: getAction,
+        clear: clearCache,
+        toHashKey: (...params) => {
+            return toHash(params.map(toKey).join('-'));
+        },
+        createKey: (namespace, params) => {
+            // Start with the namespace
+            const values = [namespace];
+            // Add all parameter values in a consistent order (sort keys)
+            Object.keys(params)
+                .sort()
+                .forEach((key) => {
+                values.push(`${key}:${toKey(params[key])}`);
+            });
+            return toHash(values.join('-'));
+        },
+        isEnabled: options?.isEnabled || ((event) => !event.locals.user)
+    };
+    return {
+        name: 'cache',
+        type: 'server',
+        configure: (config) => {
+            config = {
+                ...config,
+                panel: {
+                    ...(config.panel || {}),
+                    components: {
+                        ...(config.panel?.components || { header: [], collectionHeader: [] }),
+                        header: [...(config.panel?.components?.header || []), HeaderButton]
+                    }
+                }
+            };
+            return config;
+        },
+        routes: {
+            '/api/clear-cache': {
+                POST: clearCache
+            }
+        },
+        actions,
+        handler
+    };
+});

package/dist/core/plugins/index.d.ts

@@ -0,0 +1,20 @@
+import type { Config, RouteConfig } from '../../types.js';
+import type { Handle } from '@sveltejs/kit';
+import type { SanitizedConfigClient } from '../config/types.js';
+type MaybeAsyncFunction = (...args: any[]) => any | Promise<any>;
+export type PluginClient = {
+    name: string;
+    type: 'client';
+    configure?: <const C extends SanitizedConfigClient>(config: C) => C;
+};
+export type Plugin = {
+    name: string;
+    type: 'server';
+    configure?: <const C extends Config>(config: C) => C;
+    actions?: Record<string, MaybeAsyncFunction>;
+    routes?: Record<string, RouteConfig>;
+    handler?: Handle;
+};
+export declare function definePlugin<const F extends (options?: any) => Plugin>(factory: F): F;
+export declare function definePluginClient<const F extends (options?: any) => PluginClient>(factory: F): F;
+export {};

package/dist/core/plugins/index.js

@@ -0,0 +1,6 @@
+export function definePlugin(factory) {
+    return factory;
+}
+export function definePluginClient(factory) {
+    return factory;
+}

package/dist/core/plugins/mailer/index.server.d.ts

@@ -0,0 +1,23 @@
+import type SMTPTransport from 'nodemailer/lib/smtp-transport';
+export declare const mailer: (smtpConfig: SMTPConfig) => {
+    readonly name: "mailer";
+    readonly type: "server";
+    readonly actions: {
+        readonly sendMail: (args: {
+            to: string;
+            subject: string;
+            text: string;
+            html?: string;
+        }) => Promise<SMTPTransport.SentMessageInfo>;
+    };
+};
+export type MailerActions = ReturnType<typeof mailer>['actions'];
+export type SMTPConfig = {
+    from: string | undefined;
+    host: string | undefined;
+    port: number | undefined;
+    auth: {
+        user: string | undefined;
+        password: string | undefined;
+    };
+};

package/dist/core/plugins/mailer/index.server.js

@@ -0,0 +1,33 @@
+import { RimeError } from '../../errors/index.js';
+import nodemailer from 'nodemailer';
+import { definePlugin } from '../index.js';
+export const mailer = definePlugin((smtpConfig) => {
+    if (!smtpConfig) {
+        throw new RimeError(RimeError.CONFIG_ERROR, 'SMTP configuration is required');
+    }
+    const { password, ...restAuth } = smtpConfig.auth;
+    const options = {
+        secure: true,
+        ...smtpConfig,
+        auth: {
+            ...restAuth,
+            pass: password
+        }
+    };
+    const mailer = nodemailer.createTransport(options);
+    const sendMail = async (args) => {
+        try {
+            return await mailer.sendMail({ from: smtpConfig.from, ...args });
+        }
+        catch {
+            throw new RimeError(RimeError.MAIL_ERROR, 'Error while sending mail');
+        }
+    };
+    return {
+        name: 'mailer',
+        type: 'server',
+        actions: {
+            sendMail
+        }
+    };
+});

package/dist/core/plugins/sse/broadcast.d.ts

@@ -0,0 +1,13 @@
+import type { ContentUpdatePayload } from './types.js';
+export declare const registerWriter: (writer: WritableStreamDefaultWriter<string>) => (() => void);
+/**
+ * Sends an SSE event to all connected clients.
+ * @example
+ * broadcast({
+ *    documentType: 'events',
+ *    id: '12345',
+ *    operation: 'update',
+ *    timestamp: new Date().toISOString()
+ * });
+ */
+export declare const broadcast: (data: ContentUpdatePayload) => void;

package/dist/core/plugins/sse/broadcast.js

@@ -0,0 +1,30 @@
+/**
+ * In-memory SSE bus for broadcasting content updates.
+ * @example
+ * broadcast({  collection: 'events', id: '42', operation: 'update', timestamp: new Date().toISOString() });
+ */
+const clients = new Set();
+export const registerWriter = (writer) => {
+    clients.add(writer);
+    return () => {
+        clients.delete(writer);
+    };
+};
+/**
+ * Sends an SSE event to all connected clients.
+ * @example
+ * broadcast({
+ *    documentType: 'events',
+ *    id: '12345',
+ *    operation: 'update',
+ *    timestamp: new Date().toISOString()
+ * });
+ */
+export const broadcast = (data) => {
+    const frame = `event: rime:${data.operation}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const w of clients) {
+        void w.write(frame).catch(() => {
+            clients.delete(w);
+        });
+    }
+};

package/dist/core/plugins/sse/client.d.ts

@@ -0,0 +1,19 @@
+import type { ContentUpdatePayload } from './types.js';
+export type SSEEvent = {
+    type: string;
+    details: ContentUpdatePayload;
+};
+type SSEHandler = (event: SSEEvent) => void | Promise<void>;
+/**
+ * Opens an SSE connection with a single event handler.
+ * @example
+ * const close = openSse(async (evt) => {
+ *   if (evt.type === 'rime:update') {
+ *     if (evt.details.documentType === 'pages') {
+ *       await invalidateAll();
+ *     }
+ *   }
+ * });
+ */
+export declare const openSse: (handler: SSEHandler) => (() => void);
+export {};

package/dist/core/plugins/sse/client.js

@@ -0,0 +1,43 @@
+/**
+ * Opens an SSE connection with a single event handler.
+ * @example
+ * const close = openSse(async (evt) => {
+ *   if (evt.type === 'rime:update') {
+ *     if (evt.details.documentType === 'pages') {
+ *       await invalidateAll();
+ *     }
+ *   }
+ * });
+ */
+export const openSse = (handler) => {
+    const es = new EventSource('/api/sse');
+    console.log('[SSE] init client');
+    // Handle custom events (rime:*)
+    const handleCustomEvent = async (evt) => {
+        console.log('[SSE Client] get custom event', evt.type, evt.data);
+        try {
+            const details = JSON.parse(evt.data);
+            await handler({
+                type: evt.type,
+                details
+            });
+        }
+        catch (error) {
+            console.error('[SSE Client] Failed to parse event:', error, evt.data);
+        }
+    };
+    // Listen for all rime events
+    const eventTypes = ['rime:create', 'rime:update', 'rime:delete'];
+    eventTypes.forEach((eventType) => {
+        es.addEventListener(eventType, handleCustomEvent);
+    });
+    es.onopen = () => console.log('[SSE Client] Connection opened');
+    es.onerror = (e) => console.error('[SSE Client] Connection error:', e);
+    return () => {
+        console.log('[SSE Client] Closing connection');
+        eventTypes.forEach((eventType) => {
+            es.removeEventListener(eventType, handleCustomEvent);
+        });
+        es.close();
+    };
+};

package/dist/core/plugins/sse/index.server.d.ts

@@ -0,0 +1,17 @@
+import { type RequestHandler } from '@sveltejs/kit';
+import { broadcast } from './broadcast.js';
+export declare const sse: () => {
+    readonly name: "sse";
+    readonly type: "server";
+    readonly actions: {
+        readonly broadcast: (data: import("./types.js").ContentUpdatePayload) => void;
+    };
+    readonly routes: {
+        readonly '/api/sse': {
+            readonly GET: RequestHandler;
+        };
+    };
+};
+export type SSEActions = {
+    broadcast: typeof broadcast;
+};

package/dist/core/plugins/sse/index.server.js

@@ -0,0 +1,53 @@
+import { error } from '@sveltejs/kit';
+import { definePlugin } from '../index.js';
+import { broadcast, registerWriter } from './broadcast.js';
+export const sse = definePlugin(() => {
+    const requestHandler = async ({ request, locals }) => {
+        if (!locals.user || !locals.user.isStaff)
+            return error(404);
+        try {
+            const stream = new TransformStream();
+            const writer = stream.writable.getWriter();
+            const unregister = registerWriter(writer);
+            // Open the stream immediately
+            writer.write(`: connected ${new Date().toISOString()}\n\n`);
+            // Keep-alive ping to prevent timeouts
+            const keepAlive = setInterval(() => {
+                writer.write(`: keep-alive ${Date.now()}\n\n`).catch(() => {
+                    clearInterval(keepAlive);
+                    unregister();
+                });
+            }, 30000);
+            // Cleanup on client disconnect
+            request.signal.addEventListener('abort', () => {
+                console.log('[SSE] Client disconnected');
+                clearInterval(keepAlive);
+                unregister();
+                writer.close();
+            });
+            return new Response(stream.readable, {
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive'
+                }
+            });
+        }
+        catch (error) {
+            console.error('[SSE] Error in GET handler:', error);
+            return new Response('Internal Server Error', { status: 500 });
+        }
+    };
+    return {
+        name: 'sse',
+        type: 'server',
+        actions: {
+            broadcast
+        },
+        routes: {
+            '/api/sse': {
+                GET: requestHandler
+            }
+        }
+    };
+});