rimecms 0.22.0

package/dist/core/config/shared/versions-alias.server.js

@@ -0,0 +1,57 @@
+import { augmentHooks } from '../../collections/config/augment-hooks.server.js';
+import { withVersionsSuffix } from '../../naming.js';
+import { toKebabCase } from '../../../util/string.js';
+/**
+ * Creates versioned collection aliases for collections and areas with versioning enabled
+ *
+ * @example
+ * // If a collection "pages" has versions enabled, this will create a "pages_versions" collection
+ * // if an area "settings" has versions enabled, this will create also a "settings_versions" collection
+ * const updatedConfig = makeVersionsCollectionsAliases(config);
+ */
+export function makeVersionsCollectionsAliases(config) {
+    for (const collection of config.collections || []) {
+        if (collection.versions) {
+            const versionedCollection = {
+                slug: withVersionsSuffix(collection.slug),
+                kebab: withVersionsSuffix(toKebabCase(collection.slug)),
+                versions: undefined,
+                access: collection.access,
+                $hooks: collection.$hooks,
+                fields: collection.fields,
+                auth: collection.auth,
+                upload: collection.upload,
+                label: collection.label,
+                type: collection.type,
+                asTitle: collection.asTitle,
+                icon: collection.icon,
+                panel: false,
+                _generateTypes: false,
+                _generateSchema: false
+            };
+            config.collections = [...(config.collections || []), versionedCollection];
+        }
+    }
+    for (const area of config.areas || []) {
+        if (area.versions) {
+            let versionedCollection = {
+                slug: withVersionsSuffix(area.slug),
+                kebab: withVersionsSuffix(toKebabCase(area.slug)),
+                icon: area.icon,
+                versions: undefined,
+                access: area.access,
+                asTitle: area.asTitle,
+                $hooks: area.$hooks,
+                fields: area.fields,
+                type: 'collection',
+                label: { plural: area.label, singular: area.label },
+                panel: false,
+                _generateTypes: false,
+                _generateSchema: false
+            };
+            versionedCollection = augmentHooks(versionedCollection);
+            config.collections = [...(config.collections || []), versionedCollection];
+        }
+    }
+    return config;
+}

package/dist/core/config/types.d.ts

@@ -0,0 +1,387 @@
+import type { Adapter } from '../../adapter-sqlite/index.server.js';
+import type { PanelLanguage } from '../i18n/index.js';
+import type { Hook, HookBeforeOperation } from '../operations/hooks/index.server.js';
+import type { Plugin, PluginClient } from '../plugins/index.js';
+import type { SMTPConfig } from '../plugins/mailer/index.server.js';
+import type { Field, Option } from '../../fields/types.js';
+import type { RegisterArea, RegisterCollection } from '../../index.js';
+import type { DashboardEntry } from '../../panel/pages/dashboard/types.js';
+import type { AreaSlug, CollectionSlug, User } from '../../types.js';
+import type { AtLeastOne, Dic, WithRequired } from '../../util/types.js';
+import type { IconProps } from '@lucide/svelte';
+import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
+import type { Component } from 'svelte';
+import type { FieldBuilder } from '../fields/builders/index.js';
+import type { BaseDoc, DocType } from '../types/doc.js';
+export interface Config {
+    /** If config.siteUrl is defined, a preview button is added
+    on the panel dahsboard, pointing to this url  */
+    siteUrl?: string;
+    /**
+     * Database adapter
+     * @example
+     * export default rime({
+     *   $adapter: adapterSqlite(drizzleConfig)
+     * }
+     */
+    $adapter: {
+        createAdapter: (config: any) => Promise<Adapter>;
+        generateSchema: (config: any) => Promise<void>;
+    };
+    /** Transversal auth config */
+    $auth?: {
+        plugins: any;
+    };
+    /** List of Collection  */
+    collections?: BuiltCollection[];
+    /** List of Area  */
+    areas?: BuiltArea[];
+    /** List of locales for document i18£n
+     * @example
+     * localization: {
+     *   locales: [
+     *     {
+     *       code: 'fr',
+     *       label: 'Français'
+     *     },
+     *     {
+     *       code: 'en',
+     *       label: 'English',
+     *     }
+     *   ],
+     *   default: 'en'
+     * }
+     * ```
+     */
+    localization?: LocalizationConfig;
+    /** Define wich hosts are allowed to query the API
+     *
+     * @example
+     * ```typescript
+     * trustedOrigins: ['www.external.com']
+     * ```
+     */
+    $trustedOrigins?: string[];
+    /** Additional panel users config  */
+    staff?: AdditionalStaffConfig;
+    panel?: PanelConfig;
+    /** Enable built-in API cache */
+    $cache?: CacheConfig;
+    /** SMTP config */
+    $smtp?: SMTPConfig;
+    /** Custom API routes
+     * @example
+     * routes: {
+     * 	'/hello' : {
+     * 		GET: (event) => json({ message: 'hello' }),
+     * 		POST: (event) => sayHello(event).then(() => json({ message: 'Successfully said hello' })),
+     * 	}
+     * }
+     */
+    $routes?: Record<string, RouteConfig>;
+    /** List of client plugins */
+    plugins?: PluginClient[];
+    /** List of server plugins */
+    $plugins?: Plugin[];
+    /** Custom object for server-only config additional values  */
+    $custom?: Record<string, any>;
+    /** Custom object for both client and server config additional values  */
+    custom?: Record<string, any>;
+}
+type AccessOptions = {
+    id?: string;
+    event?: RequestEvent;
+};
+export type Access = {
+    create?: (user: User | undefined, options: AccessOptions) => boolean;
+    read?: (user: User | undefined, options: AccessOptions) => boolean;
+    update?: (user: User | undefined, options: AccessOptions) => boolean;
+    delete?: (user: User | undefined, options: AccessOptions) => boolean;
+};
+export type AdditionalStaffConfig = {
+    roles?: (string | Option)[];
+    panel?: {
+        group?: string;
+    };
+    access?: Access;
+    label?: CollectionLabel;
+    fields?: FieldBuilder<Field>[];
+};
+export type PanelConfig = {
+    /** who can accesss the panel */
+    $access?: (user: User | undefined) => boolean;
+    /** Custom panel routes that render a given component */
+    routes?: Record<string, CustomPanelRoute>;
+    /** The panel language, "en" or "fr" supports only */
+    language?: PanelLanguage;
+    /** Sidebar navigation groups labels and icons */
+    navigation?: NavigationConfig;
+    /** Specific components */
+    components?: {
+        /** Dashboard header */
+        header?: Component[];
+        /** Collection header */
+        collectionHeader?: Component[];
+        /** Full dashboard component */
+        dashboard?: Component<{
+            entries: DashboardEntry[];
+            user?: User;
+        }>;
+    };
+    /** a relative path from the "static" directory or an external url
+     * @example
+     * // for static/panel/custom.css
+     * css : '/panel/custom.css'
+     */
+    css?: string;
+};
+export type CacheConfig = {
+    isEnabled?: (event: RequestEvent) => boolean;
+};
+export type RouteConfig = {
+    POST?: RequestHandler;
+    GET?: RequestHandler;
+    PATCH?: RequestHandler;
+    DELETE?: RequestHandler;
+};
+export type LocalizationConfig = {
+    locales: LocaleConfig[];
+    default: string;
+};
+export type LocaleConfig = {
+    code: string;
+    label: string;
+};
+export type CollectionLabel = {
+    singular: string;
+    plural: string;
+    /** Label to search document, ex: Search for pages... */
+    search?: string;
+    /** Label for creation ex: New page */
+    create?: string;
+    /** Label when no document found, ex: No pages found */
+    none?: string;
+};
+export type VersionsConfig = {
+    draft?: boolean;
+    autoSave?: boolean;
+    maxVersions?: number;
+};
+export type UrlDefinition<T extends BaseDoc = BaseDoc> = (document: T) => string;
+export type PrototypePanelConfig = {
+    /** Description for the collection/area, basically displayed on the dashboard */
+    description?: string;
+    /** Sidebar navigation group */
+    group?: string;
+};
+type PrototypeConfig<S extends string = string> = {
+    slug: S;
+    /** Document fields definition */
+    fields: FieldBuilder<Field>[];
+    /** Optional icon */
+    icon?: Component<IconProps>;
+    /** Enable document versions */
+    versions?: boolean | VersionsConfig;
+    access?: Access;
+    /** If the document can be edited live, if enabled the url prop must be set also. */
+    live?: boolean;
+    /** Panel configuration, set false to hide the area/collection from the panel */
+    panel?: false | PrototypePanelConfig;
+};
+export type UploadConfig = {
+    /**
+     * Define image sizes that will be generated when an image is uploaded.
+     * A 'thumbnail' size will be added, if none provided with this name.
+     * @example
+     * ```typescript
+     * imageSizes: [
+     *   {
+     *     name: 'thumbnail',
+     *     width: 200,
+     *     height: 200,
+     *     out: ['jpg', 'webp'],
+     *     compression: 80
+     *   },
+     *   {
+     *     name: 'medium',
+     *     width: 800,
+     *     compression: 85
+     *   }
+     * ]
+     * ```
+     */
+    imageSizes?: ImageSizesConfig[];
+    /**
+     * Allowed mimeTypes
+     * @example
+     * ```typescript
+     * accept: ['image/jpeg', 'image/svg']
+     * ```
+     */
+    accept?: string[];
+};
+export type CollectionAuthConfig = ({
+    type: 'password';
+} | {
+    type: 'apiKey';
+}) & {
+    roles?: (string | Option)[];
+};
+export type Collection<S> = {
+    slug: S;
+    /** The collection label */
+    label?: string | CollectionLabel;
+    /** Auth type and availables roles */
+    auth?: boolean | CollectionAuthConfig;
+    /** Operation hooks */
+    $hooks?: CollectionHooks<S extends keyof RegisterCollection ? S : any>;
+    /** A function to generate the document URL */
+    $url?: (doc: S extends keyof RegisterCollection ? RegisterCollection[S] : any) => string;
+    /** Whether a document can have children/parent */
+    nested?: boolean;
+    /** Whether the collection support file upload */
+    upload?: boolean | UploadConfig;
+} & PrototypeConfig;
+export type Area<S> = PrototypeConfig & {
+    slug: S;
+    /** A function to generate the document URL */
+    $url?: (doc: S extends keyof RegisterArea ? RegisterArea[S] : any) => string;
+    $hooks?: AreaHooks<S extends keyof RegisterArea ? S : any>;
+    /** The area label */
+    label?: string;
+};
+type NavigationConfig = {
+    groups: Array<{
+        label: string;
+        icon: Component<IconProps>;
+    }>;
+};
+export type CustomPanelRoute = {
+    group?: string;
+    label: string;
+    icon?: Component<IconProps>;
+    component: Component;
+};
+export type ImageSizesConfig = {
+    name: string;
+    /** If none provided, will fallback to original file extesion */
+    out?: Array<'jpg' | 'webp'>;
+    /** Default compression: 60 */
+    compression?: number;
+} & AtLeastOne<{
+    width: number;
+    height: number;
+}>;
+export type BuiltCollection = Omit<Collection<string>, 'icon' | 'versions' | 'upload' | 'auth'> & {
+    slug: CollectionSlug;
+    type: 'collection';
+    /** The kebab-case version of the slug for urls */
+    kebab: string;
+    label: CollectionLabel;
+    asTitle: string;
+    asThumbnail: string | null;
+    auth?: CollectionAuthConfig;
+    versions?: Required<VersionsConfig>;
+    upload?: UploadConfig;
+    icon: Component<IconProps>;
+    access: WithRequired<Access, 'create' | 'read' | 'update' | 'delete'>;
+    _generateTypes?: false;
+    _generateSchema?: false;
+    _generateRoutes?: false;
+};
+export type BuiltAreaClient = Omit<BuiltArea, '$url' | '$hooks'>;
+export type BuiltArea = Omit<Area<string>, 'versions'> & {
+    slug: AreaSlug;
+    type: 'area';
+    /** The kebab-case version of the slug for urls */
+    kebab: string;
+    label: string;
+    asTitle: string;
+    versions?: Required<VersionsConfig>;
+    fields: FieldBuilder<Field>[];
+    icon: Component<IconProps>;
+    access: WithRequired<Access, 'create' | 'read' | 'update' | 'delete'>;
+    _generateTypes?: false;
+    _generateSchema?: false;
+    _generateRoutes?: false;
+};
+export type BuiltCollectionClient = Omit<BuiltCollection, '$url' | '$hooks'>;
+export type BuiltConfig = {
+    /** Database location relative to the root project ex: ./db/my-app.sqlite */
+    $database: string;
+    /** The database location */
+    siteUrl?: string;
+    /** list of collections */
+    collections: BuiltCollection[];
+    /** list of areas */
+    areas: BuiltArea[];
+    /** Define wich language the cms support */
+    localization?: LocalizationConfig;
+    icons: Record<string, any>;
+    $trustedOrigins: string[];
+    $routes?: Record<string, RouteConfig>;
+    $plugins?: Plugin[];
+    plugins?: PluginClient[];
+    panel: {
+        routes: Record<string, CustomPanelRoute>;
+        navigation: NavigationConfig;
+        $access: (user?: User) => boolean;
+        components: {
+            header: Component[];
+            collectionHeader?: Component[];
+            dashboard?: Component<{
+                entries: DashboardEntry[];
+                user?: User;
+            }>;
+        };
+        css?: string;
+        /**
+         * Define the panel language
+         *
+         * If none defined it will try to use the current locale if the translation is available
+         */
+        language: 'fr' | 'en';
+    };
+    $custom?: Record<string, any>;
+    custom?: Record<string, any>;
+};
+export type ServerConfigProps = '$adapter' | '$database' | '$trustedOrigins' | '$routes' | '$smtp' | '$custom' | '$plugins' | '$auth';
+export type SanitizedConfigClient = Omit<Config, ServerConfigProps | 'collections' | 'areas'> & {
+    collections?: BuiltCollectionClient[];
+    areas?: BuiltAreaClient[];
+};
+export type BuiltConfigClient = Omit<BuiltConfig, ServerConfigProps | 'panel' | 'collections' | 'areas'> & {
+    collections: BuiltCollectionClient[];
+    areas: BuiltAreaClient[];
+    icons: Dic<Component<IconProps>>;
+    panel: {
+        routes: Record<string, CustomPanelRoute>;
+        language: 'fr' | 'en';
+        navigation: NavigationConfig;
+        components: {
+            header: Component[];
+            collectionHeader?: Component[];
+            dashboard?: Component<{
+                entries: DashboardEntry[];
+                user?: User;
+            }>;
+        };
+    };
+};
+export type CollectionHooks<S extends DocType> = {
+    beforeOperation?: HookBeforeOperation<S>[];
+    beforeCreate?: (Hook<S, 'create', 'before'> | Hook<S, 'update' | 'create', 'before'>)[];
+    beforeRead?: Hook<S, 'read', 'before'>[];
+    beforeUpdate?: (Hook<S, 'update', 'before'> | Hook<S, 'update' | 'create', 'before'>)[];
+    beforeDelete?: Hook<S, 'delete', 'before'>[];
+    afterCreate?: (Hook<S, 'create', 'after'> | Hook<S, 'update' | 'create', 'after'>)[];
+    afterUpdate?: (Hook<S, 'update', 'after'> | Hook<S, 'update' | 'create', 'after'>)[];
+    afterDelete?: Hook<S, 'delete', 'after'>[];
+};
+export type AreaHooks<S extends DocType> = {
+    beforeOperation?: HookBeforeOperation<S>[];
+    beforeRead?: Hook<S, 'read', 'before'>[];
+    beforeUpdate?: (Hook<S, 'update', 'before'> | Hook<S, 'update' | 'create', 'before'>)[];
+    afterUpdate?: Hook<S, 'update', 'after'>[];
+};
+export {};

package/dist/core/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/constant.d.ts

@@ -0,0 +1,52 @@
+export declare const VERSIONS_STATUS: {
+    readonly DRAFT: "draft";
+    readonly PUBLISHED: "published";
+};
+export declare const PARAMS: {
+    /** Fetch nested documents in relation / link at a specific depth */
+    readonly DEPTH: "depth";
+    /**
+     * @TODO add documentation here for the draft param
+     */
+    readonly DRAFT: "draft";
+    /**
+     * GET operations limit number of documents
+     * @example ?limit=4
+     */
+    readonly LIMIT: "limit";
+    /** GET / CREATE / UPDATE a specific document locale
+     * @example ?locale=en
+     */
+    readonly LOCALE: "locale";
+    /** GET documents with an offset number
+     * @example ?limit=4&offset=4
+     */
+    readonly OFFSET: "offset";
+    /**
+     * Redirect or not after creation operation
+     * @example ?redirect=false
+     */
+    readonly REDIRECT: "redirect";
+    /** On fetch operation fields to be fetched
+     * @example ?depth=3
+     */
+    readonly SELECT: "select";
+    /** On fetch list operation order documents
+     * @example ?sort=-title
+     */
+    readonly SORT: "sort";
+    /** GET / UPDATE a specific version*/
+    readonly VERSION_ID: "versionId";
+    /** Parameter for panel collection list to filter out documents from a specific uploadPath */
+    readonly UPLOAD_PATH: "uploadPath";
+    /**
+     * Disable validation on CREATE / UPDATE operations
+     * @example ?skipValidation=true
+     */
+    readonly SKIP_VALIDATION: "skipValidation";
+};
+export declare const UPLOAD_PATH: {
+    readonly SEPARATOR: ":";
+    readonly ROOT_NAME: "root";
+};
+export type VersionsStatus = (typeof VERSIONS_STATUS)[keyof typeof VERSIONS_STATUS];

package/dist/core/constant.js

@@ -0,0 +1,51 @@
+export const VERSIONS_STATUS = {
+    DRAFT: 'draft',
+    PUBLISHED: 'published'
+};
+export const PARAMS = {
+    /** Fetch nested documents in relation / link at a specific depth */
+    DEPTH: 'depth',
+    /**
+     * @TODO add documentation here for the draft param
+     */
+    DRAFT: 'draft',
+    /**
+     * GET operations limit number of documents
+     * @example ?limit=4
+     */
+    LIMIT: 'limit',
+    /** GET / CREATE / UPDATE a specific document locale
+     * @example ?locale=en
+     */
+    LOCALE: 'locale',
+    /** GET documents with an offset number
+     * @example ?limit=4&offset=4
+     */
+    OFFSET: 'offset',
+    /**
+     * Redirect or not after creation operation
+     * @example ?redirect=false
+     */
+    REDIRECT: 'redirect',
+    /** On fetch operation fields to be fetched
+     * @example ?depth=3
+     */
+    SELECT: 'select',
+    /** On fetch list operation order documents
+     * @example ?sort=-title
+     */
+    SORT: 'sort',
+    /** GET / UPDATE a specific version*/
+    VERSION_ID: 'versionId',
+    /** Parameter for panel collection list to filter out documents from a specific uploadPath */
+    UPLOAD_PATH: 'uploadPath',
+    /**
+     * Disable validation on CREATE / UPDATE operations
+     * @example ?skipValidation=true
+     */
+    SKIP_VALIDATION: 'skipValidation'
+};
+export const UPLOAD_PATH = {
+    SEPARATOR: ':',
+    ROOT_NAME: 'root'
+};

package/dist/core/constant.server.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_NAME = "rimecms";

package/dist/core/constant.server.js

@@ -0,0 +1 @@
+export const PACKAGE_NAME = 'rimecms';

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

@@ -0,0 +1,11 @@
+declare function get(key: string): string | false;
+declare function set(key: string, value: string): void;
+declare function del(key: string): void;
+declare function clear(): void;
+declare const _default: {
+    get: typeof get;
+    set: typeof set;
+    clear: typeof clear;
+    delete: typeof del;
+};
+export default _default;

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

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+const dev = process.env.NODE_ENV === 'development';
+const cachePath = path.resolve(process.cwd(), '.rime');
+if (!fs.existsSync(cachePath) && dev) {
+    fs.mkdirSync(cachePath);
+}
+function get(key) {
+    const keyPath = path.join(cachePath, key + '.txt');
+    const exist = fs.existsSync(keyPath);
+    if (exist) {
+        return fs.readFileSync(keyPath).toString();
+    }
+    return false;
+}
+function set(key, value) {
+    if (!fs.existsSync(cachePath)) {
+        fs.mkdirSync(cachePath);
+    }
+    const keyPath = path.join(cachePath, key + '.txt');
+    fs.writeFileSync(keyPath, value);
+}
+function del(key) {
+    const keyPath = path.join(cachePath, key + '.txt');
+    if (fs.existsSync(keyPath)) {
+        fs.rmSync(keyPath, { force: true });
+    }
+}
+function clear() {
+    fs.rmSync(cachePath, { recursive: true });
+}
+export default {
+    get,
+    set,
+    clear,
+    delete: del
+};

package/dist/core/dev/cli/build/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare const build: (args: {
+    withDatabase?: boolean;
+}) => void;

package/dist/core/dev/cli/build/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { spawnSync } from 'child_process';
+import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { polkaServer } from './templates.js';
+import { logger } from '../../../logger/index.server.js';
+export const build = (args) => {
+    // Delete app folder if it exists
+    if (existsSync('./app')) {
+        rmSync('./app', { recursive: true, force: true });
+    }
+    // Build
+    spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
+    console.log('');
+    // Create app directory
+    mkdirSync('./app', { recursive: true });
+    // Move build folder
+    renameSync('./build', './app/build');
+    logger.info('[✓] /app folder created');
+    // Copy package.json
+    copyFileSync('./package.json', './app/package.json');
+    logger.info('[✓] package.json copied');
+    // Copy db folder if flag is set
+    if (args.withDatabase) {
+        cpSync('./db', './app/db', { recursive: true });
+        logger.info('[✓] database copied');
+    }
+    writeFileSync('./app/index.js', polkaServer);
+    logger.info('[✓] polka server created at app/index.js');
+    console.log('');
+    logger.info('Next steps :');
+    logger.info('create a /app/.env file with ORIGIN HOST and PORT variables');
+    logger.info('cd ./app');
+    logger.info('pnpm install --prod');
+    logger.info('pnpm install polka sharp serve-static');
+    logger.info('node --env-file=.env index.js');
+};

package/dist/core/dev/cli/build/templates.d.ts

@@ -0,0 +1 @@
+export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(3000, () => {\n\t\tconsole.log(\"server running\");\n\t});\n";

package/dist/core/dev/cli/build/templates.js

@@ -0,0 +1,13 @@
+export const polkaServer = `import polka from 'polka';
+import serveStatic from 'serve-static';
+import { handler } from './build/handler.js';
+
+const serve = serveStatic('./static');
+
+polka()
+	.use(serve)
+	.use(handler)
+	.listen(3000, () => {
+		console.log("server running");
+	});
+`;

package/dist/core/dev/cli/clear/index.d.ts

@@ -0,0 +1,3 @@
+export declare const clear: (args: {
+    force?: boolean;
+}) => Promise<void>;