@veap/plugins 0.0.0-stage → 0.1.1

package/dist/providers/plugins.provider.js

@@ -0,0 +1,143 @@
+import { isDatabaseInitialized } from "@veap/database";
+import { IntlService } from "@veap/intl/server";
+import { eventBus, ServiceProvider } from "@veap/kernel";
+import { bindPluginsContext } from "../common/context.js";
+import { APP_PLUGINS, ROUTER_SERVICE, SITE_LAYOUT } from "../common/tokens.js";
+import { runPluginMigrations } from "../migrations/index.js";
+import { NavigationService } from "../navigation/navigation.service.js";
+import { MIGRATION_RUNNER, PLUGIN_REPOSITORY } from "../registry/contracts.js";
+import { ensurePluginsInitialized, registerPlugins, } from "../registry/facade.js";
+import { KnexMigrationRunner } from "../registry/migration-runner.js";
+import { ActiveRecordPluginRepository } from "../registry/plugin.repository.js";
+import { PluginRegistry } from "../registry/registry.service.js";
+import { RouterService } from "../router/router.service.js";
+export class PluginsServiceProvider extends ServiceProvider {
+    config;
+    constructor(container, config) {
+        super(container);
+        this.config = config;
+    }
+    register() {
+        this.container.register({
+            token: PLUGIN_REPOSITORY,
+            useClass: ActiveRecordPluginRepository,
+            singleton: true,
+        });
+        this.container.register({
+            token: MIGRATION_RUNNER,
+            useClass: KnexMigrationRunner,
+            singleton: true,
+        });
+        this.container.register({
+            token: PluginRegistry,
+            useClass: PluginRegistry,
+            singleton: true,
+        });
+        this.container.register({
+            token: NavigationService,
+            useClass: NavigationService,
+            singleton: true,
+        });
+        this.container.register({
+            token: RouterService,
+            useClass: RouterService,
+            singleton: true,
+        });
+        this.container.register({
+            token: ROUTER_SERVICE,
+            useClass: RouterService,
+            singleton: true,
+        });
+        if (this.config?.siteLayout) {
+            this.container.register({
+                token: SITE_LAYOUT,
+                useValue: this.config.siteLayout,
+                singleton: true,
+            });
+        }
+    }
+    async boot() {
+        const registry = await this.container.resolve(PluginRegistry);
+        const navigation = await this.container.resolve(NavigationService);
+        const routerService = await this.container.resolve(RouterService);
+        bindPluginsContext({
+            registry,
+            navigation,
+            router: routerService,
+        });
+        if (this.config?.rewrites) {
+            for (const [from, to] of Object.entries(this.config.rewrites)) {
+                routerService.addRewrite(from, to);
+            }
+        }
+        if (this.config?.siteLayout) {
+            routerService.setSiteLayout(this.config.siteLayout);
+        }
+        // Register Intl loader for plugins if IntlService is available
+        if (this.container.has(IntlService)) {
+            try {
+                const intlService = await this.container.resolve(IntlService);
+                intlService.registerLoader({
+                    id: "veap:plugins",
+                    priority: 100,
+                    load: async (locale) => {
+                        let combined = {};
+                        const plugins = registry.getPlugins();
+                        for (const plugin of plugins) {
+                            if (plugin.locales && plugin.locales[locale]) {
+                                try {
+                                    const pluginDict = await plugin.locales[locale]();
+                                    const data = pluginDict.default || pluginDict;
+                                    combined = { ...combined, ...data };
+                                }
+                                catch (e) {
+                                    console.error(`[veap:Intl] Error loading locale ${locale} for plugin ${plugin.manifest.id}`, e);
+                                }
+                            }
+                        }
+                        return combined;
+                    },
+                });
+            }
+            catch (err) {
+                console.warn("[veap:plugins] Intl loader registration deferred:", err?.message || err);
+            }
+        }
+        // Clear cache when plugins are enabled/disabled
+        eventBus.subscribe("system:plugin:toggle", "route-tree-cache", async () => {
+            await routerService.clearCache();
+        });
+        // Clear cache after plugin initialization finishes
+        eventBus.subscribe("system:plugins:init:end", "route-tree-cache-init", async () => {
+            await routerService.clearCache();
+        });
+        // Register plugins from config or container
+        const pluginsToRegister = this.config?.plugins ||
+            (this.container.has(APP_PLUGINS)
+                ? await this.container.resolve(APP_PLUGINS)
+                : this.container.has("AppPlugins")
+                    ? await this.container.resolve("AppPlugins")
+                    : []);
+        if (pluginsToRegister?.length) {
+            await registerPlugins(pluginsToRegister);
+        }
+        // Automatically run plugin migrations if database is initialized and autoMigrate is not disabled
+        if (this.config?.autoMigrate !== false && isDatabaseInitialized()) {
+            try {
+                await runPluginMigrations();
+            }
+            catch (err) {
+                console.warn("[veap:plugins] Plugin migration deferred:", err?.message || err);
+            }
+        }
+        // Auto-bootstrap and synchronize database state
+        try {
+            await ensurePluginsInitialized();
+        }
+        catch (e) {
+            console.warn("[veap:plugins] Plugin initialization deferred:", e?.message || e);
+        }
+    }
+}
+// Backwards compatibility aliases
+export { PluginsServiceProvider as PluginServiceProvider, PluginsServiceProvider as RouterServiceProvider, };

package/dist/registry/contracts.d.ts

@@ -0,0 +1,72 @@
+import type { IPlugin } from "../common";
+/**
+ * Persisted status of a plugin (mirrors the `plugins` table).
+ */
+export interface PluginStatusRecord {
+    id: string;
+    enabled: boolean;
+    installed: boolean;
+    system: boolean;
+    /** Raw JSON string of the plugin config, or `null`. */
+    config?: string | null;
+    lastStep?: string | null;
+}
+/**
+ * Backwards compatibility alias for PluginStatusRecord.
+ */
+export type PluginRecord = PluginStatusRecord;
+/**
+ * In-memory status overlay kept by the registry between DB syncs.
+ */
+export interface PluginRuntimeStatus {
+    enabled: boolean;
+    installed: boolean;
+    lastStep?: string | null;
+}
+/** Payload used when a plugin row does not exist yet and must be created. */
+export interface UpsertPluginStatusRecord {
+    enabled?: boolean;
+    installed?: boolean;
+    lastStep?: string | null;
+}
+/**
+ * Plugin status persistence port.
+ */
+export interface IPluginRepository {
+    /** Returns all persisted plugin statuses. */
+    findAll(): Promise<PluginStatusRecord[]>;
+    /** Returns the persisted status of a single plugin, or `null`. */
+    findById(id: string): Promise<PluginStatusRecord | null>;
+    /**
+     * Bulk-seeds statuses for newly registered plugins.
+     * Existing rows are left alone except that `system` is re-merged.
+     */
+    seed(values: Array<{
+        id: string;
+        enabled: boolean;
+        installed: boolean;
+        system: boolean;
+    }>): Promise<void>;
+    /**
+     * Updates the status of a plugin, creating the row if it does not exist.
+     * `system` of the new row is taken from the registered plugin manifest.
+     */
+    upsertStatus(id: string, update: UpsertPluginStatusRecord, defaults: {
+        system: boolean;
+    }): Promise<void>;
+    /** Stores the raw JSON plugin config. */
+    updateConfig(id: string, configJson: string): Promise<void>;
+}
+/** Injection token for the plugin repository port. */
+export declare const PLUGIN_REPOSITORY: unique symbol;
+/**
+ * Migration runner port.
+ */
+export interface IMigrationRunner {
+    run(scope: string, migrations: any[]): Promise<void>;
+    rollback(scope: string, migrations: any[]): Promise<void>;
+}
+/** Injection token for the migration runner port. */
+export declare const MIGRATION_RUNNER: unique symbol;
+/** Convenience type re-export so consumers can name the contract. */
+export type { IPlugin };

package/dist/registry/contracts.js

@@ -0,0 +1,4 @@
+/** Injection token for the plugin repository port. */
+export const PLUGIN_REPOSITORY = Symbol.for("veap:plugins:repository");
+/** Injection token for the migration runner port. */
+export const MIGRATION_RUNNER = Symbol.for("veap:plugins:migration-runner");

package/dist/registry/facade.d.ts

@@ -0,0 +1,45 @@
+import type { IPlugin } from "../common";
+/**
+ * Module-level helpers over the {@link PluginRegistry}.
+ *
+ * They read the composition-bound plugins context instead of resolving
+ * services from the IoC container themselves.
+ */
+export declare const registerPlugins: (plugins: IPlugin[]) => Promise<void>;
+export declare const ensurePluginsInitialized: () => Promise<void>;
+export declare const applyPluginFilters: <T = any>(point: string, data: T, 
+/** Optional context (e.g. { userId }) passed to handlers as 2nd argument. */
+context?: any) => Promise<T>;
+export declare const togglePluginState: (id: string, enabled: boolean, context?: any) => Promise<void>;
+export declare const hasPluginHooks: (point: string) => Promise<boolean>;
+export declare const hasPluginExtension: (target: string, point?: string) => Promise<boolean>;
+export declare const getPluginConfig: <T = any>(id: string) => Promise<T | null>;
+export declare const updatePluginConfig: (id: string, config: any) => Promise<void>;
+export declare const getPluginsStatus: () => Promise<{
+    enabled: boolean;
+    installed: boolean;
+    lastStep: string | null;
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    extends?: string[];
+    system?: boolean;
+    hasSetup?: boolean;
+    author?: string;
+}[]>;
+export declare const getPluginStatus: (id: string) => Promise<{
+    enabled: boolean;
+    installed: boolean;
+    lastStep: string | null;
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    extends?: string[];
+    system?: boolean;
+    hasSetup?: boolean;
+    author?: string;
+} | null>;

package/dist/registry/facade.js

@@ -0,0 +1,49 @@
+import { pluginsContext } from "../common";
+/**
+ * Module-level helpers over the {@link PluginRegistry}.
+ *
+ * They read the composition-bound plugins context instead of resolving
+ * services from the IoC container themselves.
+ */
+export const registerPlugins = async (plugins) => {
+    const registry = pluginsContext().registry;
+    for (const plugin of plugins)
+        registry.register(plugin);
+};
+export const ensurePluginsInitialized = async () => {
+    await pluginsContext().registry.init();
+};
+export const applyPluginFilters = async (point, data, 
+/** Optional context (e.g. { userId }) passed to handlers as 2nd argument. */
+context) => {
+    const hooks = await pluginsContext().registry.getHooks(point);
+    let result = data;
+    for (const hook of hooks) {
+        const fn = hook.handler ?? hook.callback;
+        if (typeof fn === "function") {
+            result = await fn(result, context);
+        }
+    }
+    return result;
+};
+export const togglePluginState = async (id, enabled, context) => {
+    await pluginsContext().registry.togglePlugin(id, enabled, context);
+};
+export const hasPluginHooks = async (point) => {
+    return pluginsContext().registry.hasHooks(point);
+};
+export const hasPluginExtension = async (target, point) => {
+    return pluginsContext().registry.hasExtension(target, point);
+};
+export const getPluginConfig = async (id) => {
+    return pluginsContext().registry.getConfig(id);
+};
+export const updatePluginConfig = async (id, config) => {
+    await pluginsContext().registry.updateConfig(id, config);
+};
+export const getPluginsStatus = async () => {
+    return pluginsContext().registry.getPluginsStatus();
+};
+export const getPluginStatus = async (id) => {
+    return pluginsContext().registry.getPluginStatus(id);
+};

package/dist/registry/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./contracts";
+export * from "./facade";
+export * from "./migration-runner";
+export * from "./plugin.repository";
+export * from "./registry.service";

package/dist/registry/index.js

@@ -0,0 +1,5 @@
+export * from "./contracts";
+export * from "./facade";
+export * from "./migration-runner";
+export * from "./plugin.repository";
+export * from "./registry.service";

package/dist/registry/migration-runner.d.ts

@@ -0,0 +1,8 @@
+import type { IMigrationRunner } from "./contracts";
+/**
+ * `IMigrationRunner` adapter delegating to the knex-based migration runner.
+ */
+export declare class KnexMigrationRunner implements IMigrationRunner {
+    run(scope: string, migrations: any[]): Promise<void>;
+    rollback(scope: string, migrations: any[]): Promise<void>;
+}

package/dist/registry/migration-runner.js

@@ -0,0 +1,12 @@
+import { rollbackMigrations, runMigrations } from "@veap/database";
+/**
+ * `IMigrationRunner` adapter delegating to the knex-based migration runner.
+ */
+export class KnexMigrationRunner {
+    run(scope, migrations) {
+        return runMigrations(scope, migrations);
+    }
+    rollback(scope, migrations) {
+        return rollbackMigrations(scope, migrations);
+    }
+}

package/dist/registry/plugin.repository.d.ts

@@ -0,0 +1,19 @@
+import type { IPluginRepository, PluginStatusRecord, UpsertPluginStatusRecord } from "./contracts";
+/**
+ * `IPluginRepository` adapter backed by the `SystemPlugin` ActiveRecord model
+ * and the raw `plugins` table for bulk seeding.
+ */
+export declare class ActiveRecordPluginRepository implements IPluginRepository {
+    findAll(): Promise<PluginStatusRecord[]>;
+    findById(id: string): Promise<PluginStatusRecord | null>;
+    seed(values: Array<{
+        id: string;
+        enabled: boolean;
+        installed: boolean;
+        system: boolean;
+    }>): Promise<void>;
+    upsertStatus(id: string, update: UpsertPluginStatusRecord, defaults: {
+        system: boolean;
+    }): Promise<void>;
+    updateConfig(id: string, configJson: string): Promise<void>;
+}

package/dist/registry/plugin.repository.js

@@ -0,0 +1,74 @@
+import { SystemPlugin } from "../models/SystemPlugin";
+/**
+ * `IPluginRepository` adapter backed by the `SystemPlugin` ActiveRecord model
+ * and the raw `plugins` table for bulk seeding.
+ */
+export class ActiveRecordPluginRepository {
+    async findAll() {
+        const rows = await SystemPlugin.all();
+        return rows.map((row) => ({
+            id: row.id,
+            enabled: Boolean(row.enabled),
+            installed: Boolean(row.installed),
+            system: Boolean(row.system),
+            config: row.config ?? null,
+            lastStep: row.lastStep ?? null,
+        }));
+    }
+    async findById(id) {
+        const row = await SystemPlugin.find(id);
+        if (!row)
+            return null;
+        return {
+            id,
+            enabled: Boolean(row.enabled),
+            installed: Boolean(row.installed),
+            system: Boolean(row.system),
+            config: row.config ?? null,
+            lastStep: row.lastStep ?? null,
+        };
+    }
+    async seed(values) {
+        if (values.length === 0)
+            return;
+        const { getKnex } = await import("@veap/database");
+        const knex = getKnex();
+        await knex("plugins")
+            .insert(values.map((p) => ({
+            id: p.id,
+            enabled: p.enabled,
+            installed: p.installed,
+            system: p.system,
+        })))
+            .onConflict("id")
+            .merge(["system"]);
+    }
+    async upsertStatus(id, update, defaults) {
+        const existing = await SystemPlugin.find(id);
+        if (existing) {
+            if (update.enabled !== undefined)
+                existing.setAttribute("enabled", update.enabled);
+            if (update.installed !== undefined)
+                existing.setAttribute("installed", update.installed);
+            if (update.lastStep !== undefined)
+                existing.setAttribute("lastStep", update.lastStep);
+            existing.setAttribute("updatedAt", new Date());
+            await existing.save();
+            return;
+        }
+        await SystemPlugin.create({
+            id,
+            enabled: update.enabled ?? false,
+            installed: update.installed ?? false,
+            lastStep: update.lastStep ?? null,
+            system: defaults.system,
+            updatedAt: new Date(),
+        });
+    }
+    async updateConfig(id, configJson) {
+        await SystemPlugin.where("id", id).update({
+            config: configJson,
+            updatedAt: new Date(),
+        });
+    }
+}

package/dist/registry/registry.service.d.ts

@@ -0,0 +1,69 @@
+import { type IEventBus, type ILogger } from "@veap/kernel";
+import type { IPlugin } from "../common";
+import { type IMigrationRunner, type IPluginRepository } from "./contracts";
+export declare class PluginRegistry {
+    private readonly repository;
+    private readonly migrationRunner;
+    private readonly logger;
+    private readonly eventBus;
+    private plugins;
+    private pluginStatus;
+    private processingPlugins;
+    private initPromise;
+    private initialized;
+    constructor(repository: IPluginRepository, migrationRunner: IMigrationRunner, logger: ILogger, eventBus: IEventBus);
+    /** Lookup a plugin by id, falling back to the npm-name form. */
+    private findPlugin;
+    register(plugin: IPlugin): void;
+    private updateStatus;
+    private updateStep;
+    private sortPlugins;
+    init(): Promise<void>;
+    getPlugins(): IPlugin[];
+    getEnabledPlugins(): IPlugin[];
+    getPlugin(id: string): IPlugin | undefined;
+    getPluginsStatus(): Promise<{
+        enabled: boolean;
+        installed: boolean;
+        lastStep: string | null;
+        id: string;
+        name: string;
+        version: string;
+        description?: string;
+        dependencies?: string[];
+        extends?: string[];
+        system?: boolean;
+        hasSetup?: boolean;
+        author?: string;
+    }[]>;
+    getPluginStatus(id: string): Promise<{
+        enabled: boolean;
+        installed: boolean;
+        lastStep: string | null;
+        id: string;
+        name: string;
+        version: string;
+        description?: string;
+        dependencies?: string[];
+        extends?: string[];
+        system?: boolean;
+        hasSetup?: boolean;
+        author?: string;
+    } | null>;
+    getHooks(point: string): Promise<import("..").PluginHook[]>;
+    getExtensions(target: string, point: string, includeDisabled?: boolean, context?: {
+        roles?: string[];
+        permissions?: string[];
+    }): Promise<import("..").PluginExtension[]>;
+    getWidgets(area: string, context?: {
+        roles?: string[];
+        permissions?: string[];
+    }): Promise<import("..").PluginWidget[]>;
+    private delay;
+    togglePlugin(id: string, enabled: boolean, context?: any): Promise<void>;
+    hasHooks(point: string): Promise<boolean>;
+    hasExtension(target: string, point?: string): Promise<boolean>;
+    getConfig<T>(id: string): Promise<T | null>;
+    updateConfig(id: string, config: any): Promise<void>;
+}
+export { applyPluginFilters, ensurePluginsInitialized, getPluginConfig, getPluginStatus, getPluginsStatus, hasPluginExtension, hasPluginHooks, registerPlugins, togglePluginState, updatePluginConfig, } from "./facade";