@veap/plugins 0.0.0-stage → 0.1.0

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 IMigrationRunner, type IPluginRepository } from "./contracts";
+import type { IPlugin } from "../common";
+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";