flarecms 0.2.2 → 0.2.3

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>;
+}

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

@@ -0,0 +1,71 @@
+import type { PluginCapability } from '../types.js';
+/**
+ * Interface for the Cloudflare Worker Loader API.
+ */
+export interface WorkerLoader {
+    get(id: string, configFactory: () => WorkerLoaderConfig): WorkerStub;
+}
+/**
+ * Configuration for a dynamic worker.
+ */
+export interface WorkerLoaderConfig {
+    compatibilityDate?: string;
+    compatibilityFlags?: string[];
+    mainModule: string;
+    modules: Record<string, {
+        js: string;
+    } | {
+        text: string;
+    } | {
+        data: ArrayBuffer;
+    }>;
+    env?: Record<string, any>;
+    limits?: {
+        cpuMs?: number;
+        subRequests?: number;
+    };
+}
+/**
+ * A stub for interacting with a dynamic worker.
+ */
+export interface WorkerStub {
+    fetch(request: Request | string, init?: RequestInit): Promise<Response>;
+    get(pluginId: string): any;
+}
+/**
+ * Metadata passed to the PluginBridge when it's instantiated.
+ */
+export interface PluginBridgeProps {
+    pluginId: string;
+    version: string;
+    capabilities: PluginCapability[];
+    allowedHosts: string[];
+    storageCollections: string[];
+}
+/**
+ * Typing for the environment available to the PluginBridge.
+ */
+export interface PluginBridgeEnv {
+    DB: any;
+    KV: any;
+}
+/**
+ * The RPC interface exposed by the PluginBridge.
+ */
+export interface PluginBridgeInterface {
+    kvGet(key: string): Promise<any>;
+    kvSet(key: string, value: any): Promise<void>;
+    kvDelete(key: string): Promise<boolean>;
+    kvList(prefix?: string): Promise<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<any>;
+    contentGet(collection: string, id: string): Promise<any>;
+    contentList(collection: string, opts?: any): Promise<any>;
+    contentCreate(collection: string, data: any): Promise<any>;
+    contentUpdate(collection: string, id: string, data: any): Promise<any>;
+    contentDelete(collection: string, id: string): Promise<boolean>;
+    httpFetch(url: string, init?: any): Promise<any>;
+    log(level: string, message: string, data?: any): void;
+}

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

@@ -0,0 +1,6 @@
+import type { PluginManifest } from '../types.js';
+/**
+ * Generates the JavaScript wrapper code that runs inside the Worker Isolate.
+ * It sets up the RPC bridge to the host and provides the PluginContext.
+ */
+export declare function generatePluginWrapper(manifest: PluginManifest): string;