flarecms 0.2.1 → 0.2.3

package/dist/client/store/plugins.d.ts

@@ -0,0 +1,21 @@
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    capabilities: string[];
+    routes: string[];
+    adminPages?: Array<{
+        path: string;
+        label?: string;
+        icon?: string;
+    }>;
+    adminWidgets?: Array<{
+        id: string;
+        title?: string;
+        size?: string;
+    }>;
+}
+/**
+ * Store for active plugins list
+ */
+export declare const $plugins: import("@nanostores/query").FetcherStore<PluginManifest[], any>;

package/dist/client/store/router.d.ts

@@ -0,0 +1,84 @@
+import { type Router } from '@nanostores/router';
+declare const ROUTE_PATTERNS: {
+    readonly home: "";
+    readonly setup: "/setup";
+    readonly login: "/login";
+    readonly signup: "/signup";
+    readonly collections: "/collections";
+    readonly users: "/users";
+    readonly settings: "/settings";
+    readonly settings_general: "/settings/general";
+    readonly settings_seo: "/settings/seo";
+    readonly settings_security: "/settings/security";
+    readonly settings_signup: "/settings/signup";
+    readonly settings_api: "/settings/api";
+    readonly device: "/device";
+    readonly collection: "/collection/:id/:slug";
+    readonly plugins: "/plugins";
+    readonly plugin_page: "/plugins/:pluginId";
+    readonly plugin_subpage: "/plugins/:pluginId/:page";
+    readonly document_list: "/:slug";
+    readonly document_edit: "/:slug/:id";
+};
+/**
+ * ExtractParams is a mapped type that extracts the parameters for each route.
+ */
+type ExtractParams<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
+} : Path extends `${string}:${infer Param}` ? {
+    [K in Param]: string;
+} : {};
+/**
+ * RouteParams is a mapped type that extracts the parameters for each route.
+ */
+type RouteParams = {
+    [K in RouteName]: ExtractParams<RoutePatterns[K]>;
+};
+/**
+ * RoutePatterns is a mapped type that extracts the parameters for each route.
+ */
+type RoutePatterns = typeof ROUTE_PATTERNS;
+/**
+ * RouteName is a mapped type that extracts the parameters for each route.
+ */
+export type RouteName = keyof RoutePatterns;
+export declare const $router: import("nanostores").PreinitializedMapStore<{
+    hash: string;
+    params: any;
+    path: string;
+    route: any;
+    search: Record<string, string>;
+}> & object;
+/**
+ * Initializes the router with a specific base path.
+ */
+export declare function initRouter(base: string): Router<{
+    readonly home: "";
+    readonly setup: "/setup";
+    readonly login: "/login";
+    readonly signup: "/signup";
+    readonly collections: "/collections";
+    readonly users: "/users";
+    readonly settings: "/settings";
+    readonly settings_general: "/settings/general";
+    readonly settings_seo: "/settings/seo";
+    readonly settings_security: "/settings/security";
+    readonly settings_signup: "/settings/signup";
+    readonly settings_api: "/settings/api";
+    readonly device: "/device";
+    readonly collection: "/collection/:id/:slug";
+    readonly plugins: "/plugins";
+    readonly plugin_page: "/plugins/:pluginId";
+    readonly plugin_subpage: "/plugins/:pluginId/:page";
+    readonly document_list: "/:slug";
+    readonly document_edit: "/:slug/:id";
+}>;
+/**
+ * Navigate to a named route.
+ */
+export declare function navigate<T extends RouteName>(route: T, params?: RouteParams[T], search?: Record<string, string | number>): void;
+/**
+ * Redirect to a named route.
+ */
+export declare function redirect<T extends RouteName>(route: T, params?: any, search?: Record<string, string | number>): void;
+export {};

package/dist/client/store/schema.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionSchema, Field } from '../types';
+export declare const $activeSlug: import("nanostores").PreinitializedWritableAtom<string | null> & object;
+export declare const $schema: import("@nanostores/query").FetcherStore<CollectionSchema, any>;
+export declare const $addField: import("@nanostores/query").MutatorStore<Partial<Field> & {
+    collectionSlug: string;
+}, Field, any>;
+export declare const $reloadSchema: () => void;

package/dist/client/store/settings.d.ts

@@ -0,0 +1,7 @@
+export interface Settings {
+    [key: string]: string;
+}
+export declare const $settings: import("nanostores").PreinitializedMapStore<Settings> & object;
+export declare function loadSettings(): Promise<void>;
+export declare function updateSettingsLocally(newSettings: Settings): void;
+export declare function getSetting(key: string, fallback?: string): string;

package/dist/client/types.d.ts

@@ -0,0 +1,31 @@
+export interface Collection {
+    id: string;
+    slug: string;
+    label: string;
+    label_singular: string | null;
+    description: string | null;
+    icon: string | null;
+    is_public: number;
+    features: string[];
+    url_pattern: string | null;
+    createdAt: string;
+}
+export interface Field {
+    id: string;
+    collectionId: string;
+    label: string;
+    slug: string;
+    type: 'text' | 'richtext' | 'number' | 'boolean' | 'date';
+    required: boolean;
+    createdAt: string;
+}
+export interface CollectionSchema extends Collection {
+    fields: Field[];
+}
+export interface ContentEntry {
+    id: string;
+    slug: string;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+    [key: string]: any;
+}

package/dist/db/dynamic.d.ts

@@ -0,0 +1,5 @@
+import type { FlareDb } from "./index";
+export declare const FIELD_TYPE_MAP: Record<string, string>;
+export declare function createCollectionTable(db: FlareDb, slug: string): Promise<void>;
+export declare function addFieldToTable(db: FlareDb, collectionSlug: string, fieldSlug: string, type: string): Promise<void>;
+export declare function ensureUniqueSlug(db: FlareDb, collectionName: string, baseSlug: string, excludeId?: string): Promise<string>;

package/dist/db/index.d.ts

@@ -0,0 +1,8 @@
+import { Kysely } from "kysely";
+import type { Database } from "./schema";
+import type { D1Database } from "@cloudflare/workers-types";
+export * from "./schema";
+export * from "./dynamic";
+export * from "./migrator";
+export declare const createDb: (d1: D1Database) => Kysely<Database>;
+export type FlareDb = ReturnType<typeof createDb>;

package/dist/db/migrations/001_initial_schema.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<any>): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;

package/dist/db/migrations/002_auth_tables.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<any>): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;

package/dist/db/migrations/003_plugins.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<any>): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;

package/dist/db/migrator.d.ts

@@ -0,0 +1,10 @@
+import type { FlareDb } from './index';
+/**
+ * Manual D1-safe migration runner.
+ * We avoid Kysely's built-in Migrator because it uses introspection (sqlite_master)
+ * which Cloudflare D1 restricts, causing SQLITE_AUTH errors.
+ */
+export declare function runMigrations(db: FlareDb): Promise<{
+    name: string;
+    status: "Success" | "Skipped" | "Error";
+}[]>;

package/dist/db/schema.d.ts

@@ -0,0 +1,151 @@
+import type { ColumnType, Selectable, Insertable, Updateable } from 'kysely';
+export interface Database {
+    options: OptionsTable;
+    fc_collections: CollectionsTable;
+    fc_fields: FieldsTable;
+    fc_users: UsersTable;
+    fc_passkeys: PasskeysTable;
+    fc_sessions: SessionsTable;
+    fc_api_tokens: ApiTokensTable;
+    fc_oauth_accounts: OAuthAccountsTable;
+    fc_verification_tokens: VerificationTokensTable;
+    fc_device_codes: DeviceCodesTable;
+    fc_plugins: PluginsTable;
+    _fc_plugin_storage: PluginStorageTable;
+    _fc_cron_tasks: CronTasksTable;
+    [tableName: string]: any;
+}
+export interface PluginsTable {
+    id: string;
+    plugin_id: string;
+    version: string;
+    status: string;
+    capabilities: string | null;
+    allowed_hosts: string | null;
+    storage_config: string | null;
+    manifest: string | null;
+    backend_code: string | null;
+    installed_at: ColumnType<string, string | undefined, never>;
+    activated_at: string | null;
+}
+export interface PluginStorageTable {
+    plugin_id: string;
+    collection: string;
+    id: string;
+    data: string;
+    updated_at: ColumnType<string, string | undefined, string>;
+}
+export interface CronTasksTable {
+    id: string;
+    plugin_id: string;
+    schedule: string;
+    last_run_at: string | null;
+    next_run_at: string | null;
+    enabled: ColumnType<number, number | undefined, number>;
+}
+export interface OptionsTable {
+    name: string;
+    value: string;
+}
+export type Option = Selectable<OptionsTable>;
+export type NewOption = Insertable<OptionsTable>;
+export interface CollectionsTable {
+    id: string;
+    slug: string;
+    label: string;
+    label_singular: string | null;
+    description: string | null;
+    icon: string | null;
+    is_public: ColumnType<number, number | undefined, number>;
+    features: string | null;
+    url_pattern: string | null;
+    created_at: ColumnType<string, string | undefined, never>;
+    updated_at: ColumnType<string, string | undefined, string>;
+}
+export type Collection = Selectable<CollectionsTable>;
+export type NewCollection = Insertable<CollectionsTable>;
+export type CollectionUpdate = Updateable<CollectionsTable>;
+export interface FieldsTable {
+    id: string;
+    collection_id: string;
+    label: string;
+    slug: string;
+    type: string;
+    required: ColumnType<number, number | undefined, number>;
+    created_at: ColumnType<string, string | undefined, never>;
+}
+export type Field = Selectable<FieldsTable>;
+export type NewField = Insertable<FieldsTable>;
+export interface UsersTable {
+    id: string;
+    email: string;
+    password: string | null;
+    role: string;
+    disabled: ColumnType<number, number | undefined, number>;
+    created_at: ColumnType<string, string | undefined, never>;
+    updated_at: ColumnType<string, string | undefined, string>;
+}
+export type User = Selectable<UsersTable>;
+export type NewUser = Insertable<UsersTable>;
+export type UserUpdate = Updateable<UsersTable>;
+export interface PasskeysTable {
+    id: string;
+    user_id: string;
+    name: string | null;
+    public_key: string;
+    counter: number;
+    device_type: string;
+    backed_up: number;
+    transports: string | null;
+    created_at: ColumnType<string, string | undefined, never>;
+    last_used_at: string | null;
+}
+export type Passkey = Selectable<PasskeysTable>;
+export type NewPasskey = Insertable<PasskeysTable>;
+export type PasskeyUpdate = Updateable<PasskeysTable>;
+export interface SessionsTable {
+    id: string;
+    user_id: string;
+    expires_at: string;
+}
+export type Session = Selectable<SessionsTable>;
+export type NewSession = Insertable<SessionsTable>;
+export type SessionUpdate = Updateable<SessionsTable>;
+export interface ApiTokensTable {
+    id: string;
+    user_id: string;
+    name: string;
+    hash: string;
+    scopes: string;
+    expires_at: string | null;
+    last_used_at: string | null;
+    created_at: ColumnType<string, string | undefined, never>;
+}
+export type ApiToken = Selectable<ApiTokensTable>;
+export type NewApiToken = Insertable<ApiTokensTable>;
+export interface OAuthAccountsTable {
+    provider_id: string;
+    provider_user_id: string;
+    user_id: string;
+}
+export type OAuthAccount = Selectable<OAuthAccountsTable>;
+export type NewOAuthAccount = Insertable<OAuthAccountsTable>;
+export interface VerificationTokensTable {
+    identifier: string;
+    token: string;
+    expires_at: string;
+}
+export type VerificationToken = Selectable<VerificationTokensTable>;
+export type NewVerificationToken = Insertable<VerificationTokensTable>;
+export interface DeviceCodesTable {
+    device_code: string;
+    user_code: string;
+    client_id: string;
+    user_id: string | null;
+    scopes: string;
+    expires_at: string;
+    created_at: ColumnType<string, string | undefined, never>;
+}
+export type DeviceCode = Selectable<DeviceCodesTable>;
+export type NewDeviceCode = Insertable<DeviceCodesTable>;
+export type DeviceCodeUpdate = Updateable<DeviceCodesTable>;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './auth';
+export * from './db';
+export * from './server';
+export * from './client';
+export * from './types';
+import { createFlareAPI } from './server';
+/**
+ * @deprecated Use createFlareAPI from 'flarecms/server' for better modularity.
+ */
+export declare const flarecms: typeof createFlareAPI;
+export * from './plugins';

package/dist/plugins/adapt-entry.d.ts

@@ -0,0 +1,5 @@
+import type { PluginDescriptor, ResolvedPlugin, FlarePlugin } from './types.js';
+/**
+ * Adapts any plugin input (Descriptor or full Plugin object) into a ResolvedPlugin.
+ */
+export declare function adaptEntry(input: PluginDescriptor | FlarePlugin): ResolvedPlugin;

package/dist/plugins/context.d.ts

@@ -0,0 +1,21 @@
+import type { FlareDb } from '../db/index.js';
+import type { PluginContext, PluginCapability } from './types.js';
+export interface ContextFactoryOptions {
+    pluginId: string;
+    version: string;
+    capabilities: PluginCapability[];
+    allowedHosts: string[];
+    storageCollections: string[];
+    db: FlareDb;
+    siteInfo: {
+        name: string;
+        url: string;
+        locale: string;
+    };
+    encryptionSecret?: string;
+}
+/**
+ * Creates an in-process (trusted) PluginContext.
+ * Operations are executed directly against the provided database.
+ */
+export declare function createPluginContext(options: ContextFactoryOptions): PluginContext;

package/dist/plugins/define-plugin.d.ts

@@ -0,0 +1,22 @@
+import type { FlarePluginDefinition } from './types.js';
+/**
+ * definePlugin() Helper
+ *
+ * Creates a properly typed plugin definition. This is an identity function
+ * that provides type inference and basic validation for the standard plugin format.
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin } from "flarecms/plugins";
+ *
+ * export default definePlugin({
+ *   hooks: {
+ *     "content:afterSave": async (event, ctx) => {
+ *       ctx.log.info("Content saved!");
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function definePlugin<T extends FlarePluginDefinition>(definition: T): T;
+export default definePlugin;

package/dist/plugins/hooks.d.ts

@@ -0,0 +1,37 @@
+import type { ResolvedPlugin } from './types.js';
+import type { FlareDb } from '../db/index.js';
+/**
+ * HookPipeline manages the registration and execution of hooks across all plugins.
+ */
+export declare class HookPipeline {
+    private hooks;
+    private plugins;
+    private db;
+    private siteInfo;
+    constructor(plugins: ResolvedPlugin[], db: FlareDb, siteInfo: {
+        name: string;
+        url: string;
+        locale: string;
+    });
+    /**
+     * Run a chain of hooks that can modify the event data (Waterfall pattern).
+     * Example: content:beforeSave
+     */
+    runChain<T>(hookName: string, initialData: T): Promise<T>;
+    /**
+     * Run all hooks in parallel (Fire-and-forget pattern).
+     * Example: content:afterSave
+     */
+    runParallel(hookName: string, event: unknown): Promise<void>;
+    /**
+     * Run hooks where any hook returning 'false' aborts the operation.
+     * Example: content:beforeDelete
+     */
+    runVeto(hookName: string, event: unknown): Promise<boolean>;
+    runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<Record<string, unknown>>;
+    runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<void>;
+    runContentBeforeDelete(id: string, collection: string): Promise<boolean>;
+    runContentAfterDelete(id: string, collection: string): Promise<void>;
+    private createContextForHook;
+    private executeWithTimeout;
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { definePlugin } from './define-plugin.js';
+export { PluginManager } from './manager.js';
+export { NoopSandboxRunner, SandboxNotAvailableError } from './noop-sandbox.js';
+export { adaptEntry } from './adapt-entry.js';
+export { createPluginContext } from './context.js';
+export { pluginMiddleware } from './middleware.js';
+export type { BlockInteraction, BlockResponse, FlarePluginDefinition, FlarePlugin, PluginDescriptor, PluginManifest, PluginContext, SandboxRunner, SandboxRunnerFactory, PluginCapability, SerializedRequest, RouteCtx, } from './types';

package/dist/plugins/manager.d.ts

@@ -0,0 +1,41 @@
+import { type InvokeRouteOptions } from './routes.js';
+import type { ResolvedPlugin, BlockInteraction, BlockResponse } from './types.js';
+import type { FlareDb } from '../db/index.js';
+/**
+ * PluginManager is the central orchestrator for the FlareCMS plugin system.
+ * It coordinates hook execution, route handling, and plugin lifecycle.
+ */
+export declare class PluginManager {
+    plugins: ResolvedPlugin[];
+    db: FlareDb;
+    siteInfo: {
+        name: string;
+        url: string;
+        locale: string;
+    };
+    encryptionSecret?: string | undefined;
+    private hookPipeline;
+    private routeRegistry;
+    constructor(plugins: ResolvedPlugin[], db: FlareDb, siteInfo: {
+        name: string;
+        url: string;
+        locale: string;
+    }, encryptionSecret?: string | undefined);
+    runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<Record<string, unknown>>;
+    runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<void>;
+    runContentBeforeDelete(id: string, collection: string): Promise<boolean>;
+    runContentAfterDelete(id: string, collection: string): Promise<void>;
+    invokeRoute(pluginId: string, routeName: string, options: InvokeRouteOptions): Promise<unknown>;
+    /**
+     * Invokes the administrative UI handler for a plugin.
+     */
+    invokeAdmin(pluginId: string, interaction: BlockInteraction): Promise<BlockResponse>;
+    /**
+     * Returns the list of active plugins and their basic info.
+     */
+    getActivePlugins(): ResolvedPlugin[];
+    /**
+     * Checks if a specific plugin is loaded and active.
+     */
+    isActive(pluginId: string): boolean;
+}

package/dist/plugins/middleware.d.ts

@@ -0,0 +1,8 @@
+import type { MiddlewareHandler } from 'hono';
+import type { FlarePlugin, PluginDescriptor } from './types.js';
+/**
+ * Hono middleware to initialize the PluginManager.
+ *
+ * @param staticPlugins - Plugins declared at build-time/config.
+ */
+export declare function pluginMiddleware(staticPlugins?: (PluginDescriptor | FlarePlugin)[]): MiddlewareHandler;

package/dist/plugins/noop-sandbox.d.ts

@@ -0,0 +1,18 @@
+import type { SandboxRunner, SandboxedPlugin, PluginManifest } from './types.js';
+/**
+ * Error thrown when a sandboxed operation is attempted but no sandbox runner is available.
+ */
+export declare class SandboxNotAvailableError extends Error {
+    constructor(reason?: string);
+}
+/**
+ * No-op Sandbox Runner
+ *
+ * Acts as a fallback for environments where sandboxing (e.g. Worker Loader)
+ * is not supported or configured.
+ */
+export declare class NoopSandboxRunner implements SandboxRunner {
+    isAvailable(): boolean;
+    load(_manifest: PluginManifest, _code: string): Promise<SandboxedPlugin>;
+    terminateAll(): Promise<void>;
+}

package/dist/plugins/routes.d.ts

@@ -0,0 +1,32 @@
+import type { ResolvedPlugin, SerializedRequest } from './types.js';
+import type { FlareDb } from '../db/index.js';
+export interface InvokeRouteOptions {
+    input: unknown;
+    request: SerializedRequest;
+}
+/**
+ * PluginRouteRegistry manages custom HTTP routes exposed by plugins.
+ */
+export declare class PluginRouteRegistry {
+    private plugins;
+    private db;
+    private siteInfo;
+    private encryptionSecret?;
+    constructor(db: FlareDb, siteInfo: {
+        name: string;
+        url: string;
+        locale: string;
+    }, encryptionSecret?: string);
+    /**
+     * Registers all routes for a given plugin.
+     */
+    register(plugin: ResolvedPlugin): void;
+    /**
+     * Invokes a specific plugin route.
+     */
+    invoke(pluginId: string, routeName: string, options: InvokeRouteOptions): Promise<unknown>;
+    /**
+     * Gets all registered routes for a specific plugin.
+     */
+    getRoutes(pluginId: string): string[];
+}

package/dist/plugins/sandbox/bridge.d.ts

@@ -0,0 +1,45 @@
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import type { PluginBridgeInterface, PluginBridgeEnv } from './types.js';
+/**
+ * PluginBridge is the RPC gateway that runs in the Host process.
+ * It exposes secure methods to the Sandboxed Plugin via Service Bindings.
+ */
+export declare class PluginBridge extends WorkerEntrypoint<PluginBridgeEnv> implements PluginBridgeInterface {
+    private props;
+    constructor(ctx: any, env: PluginBridgeEnv);
+    private get db();
+    private hasCap;
+    kvGet(key: string): Promise<any>;
+    kvSet(key: string, value: any): Promise<void>;
+    kvDelete(key: string): Promise<boolean>;
+    kvList(prefix?: string): Promise<{
+        key: any;
+        value: any;
+    }[]>;
+    storageGet(collection: string, id: string): Promise<any>;
+    storagePut(collection: string, id: string, data: any): Promise<void>;
+    storageDelete(collection: string, id: string): Promise<boolean>;
+    storageQuery(collection: string, opts?: any): Promise<{
+        items: any[];
+        hasMore: boolean;
+    }>;
+    contentGet(collection: string, id: string): Promise<{
+        [x: string]: any;
+    } | undefined>;
+    contentList(collection: string, opts?: any): Promise<{
+        items: {
+            [x: string]: any;
+        }[];
+        hasMore: boolean;
+    }>;
+    contentCreate(collection: string, data: any): Promise<import("kysely").InsertResult[]>;
+    contentUpdate(collection: string, id: string, data: any): Promise<import("kysely").UpdateResult[]>;
+    contentDelete(collection: string, id: string): Promise<boolean>;
+    httpFetch(url: string, init?: any): Promise<{
+        status: number;
+        ok: boolean;
+        headers: Record<string, string>;
+        text: string;
+    }>;
+    log(level: string, message: string, data?: any): void;
+}

package/dist/plugins/sandbox/runner.d.ts

@@ -0,0 +1,14 @@
+import type { SandboxRunner, SandboxedPlugin, PluginManifest, SandboxOptions } from '../types.js';
+import type { WorkerLoader } from './types.js';
+/**
+ * Sandbox Runner implementation for Cloudflare Workers.
+ * Uses the dynamic 'Worker Loader' API to spawn V8 isolates.
+ */
+export declare class CloudflareSandboxRunner implements SandboxRunner {
+    private loader;
+    private options;
+    constructor(loader: WorkerLoader, options: SandboxOptions);
+    isAvailable(): boolean;
+    load(manifest: PluginManifest, code: string): Promise<SandboxedPlugin>;
+    terminateAll(): Promise<void>;
+}