@veap/plugins 0.0.0-stage → 0.1.1

package/dist/registry/registry.service.js

@@ -0,0 +1,535 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { AppError, EVENT_BUS, Inject, Injectable, LOGGER, } from "@veap/kernel";
+import { MIGRATION_RUNNER, PLUGIN_REPOSITORY, } from "./contracts";
+/**
+ * Normalizes an npm dependency string (e.g. "@veap/media-plugin") to a registered plugin id (e.g. "media-plugin").
+ */
+const resolveDependencyId = (depId) => depId.replace(/^@[^/]+\//, "");
+let PluginRegistry = class PluginRegistry {
+    repository;
+    migrationRunner;
+    logger;
+    eventBus;
+    plugins = new Map();
+    pluginStatus = new Map();
+    processingPlugins = new Set();
+    initPromise = null;
+    initialized = false;
+    constructor(repository, migrationRunner, logger, eventBus) {
+        this.repository = repository;
+        this.migrationRunner = migrationRunner;
+        this.logger = logger;
+        this.eventBus = eventBus;
+    }
+    /** Lookup a plugin by id, falling back to the npm-name form. */
+    findPlugin(id) {
+        return this.plugins.get(id) ?? this.plugins.get(resolveDependencyId(id));
+    }
+    register(plugin) {
+        if (this.plugins.has(plugin.manifest.id)) {
+            // return;
+        }
+        this.plugins.set(plugin.manifest.id, plugin);
+        // Rekurencyjna rejestracja wtyczek zależnych
+        if (plugin.plugins && Array.isArray(plugin.plugins)) {
+            for (const nested of plugin.plugins) {
+                this.register(nested);
+            }
+        }
+        if (process.env.NODE_ENV === "development") {
+            // In development, we want to allow re-registration to pick up HMR changes
+            this.plugins.set(plugin.manifest.id, plugin);
+        }
+    }
+    async updateStatus(id, update) {
+        const current = this.pluginStatus.get(id) || {
+            enabled: false,
+            installed: false,
+            lastStep: null,
+        };
+        const next = { ...current, ...update };
+        this.pluginStatus.set(id, next);
+        if (update.lastStep !== undefined && update.lastStep !== null) {
+            this.logger.info("PluginRegistry", `"${id}" step: ${update.lastStep}`);
+        }
+        const isStateTransition = update.enabled !== undefined || update.installed !== undefined;
+        try {
+            await this.repository.upsertStatus(id, update, {
+                system: this.plugins.get(id)?.manifest.system ?? false,
+            });
+        }
+        catch (e) {
+            if (isStateTransition) {
+                // Rollback in-memory state on DB failure to avoid split-brain
+                this.pluginStatus.set(id, current);
+                this.logger.error("PluginRegistry", `Critical: DB status sync failed for plugin "${id}". Rolling back in-memory state:`, e);
+                throw e;
+            }
+            else {
+                // Ephemeral progress steps (lastStep) can safely fail without aborting
+                this.logger.warn("PluginRegistry", `DB step sync failed for "${id}":`, e);
+            }
+        }
+    }
+    async updateStep(id, step) {
+        await this.updateStatus(id, { lastStep: step });
+    }
+    sortPlugins(plugins) {
+        const sorted = [];
+        const visited = new Set();
+        const processing = new Set();
+        const visit = (plugin) => {
+            if (visited.has(plugin.manifest.id))
+                return;
+            if (processing.has(plugin.manifest.id)) {
+                throw AppError.Internal(`Circular dependency detected: ${plugin.manifest.id}`);
+            }
+            processing.add(plugin.manifest.id);
+            const dependencies = plugin.manifest.dependencies || [];
+            for (const depId of dependencies) {
+                const depPlugin = this.findPlugin(depId);
+                if (depPlugin) {
+                    visit(depPlugin);
+                }
+                else {
+                    this.logger.warn("PluginRegistry", `Missing dependency: ${depId} for plugin ${plugin.manifest.id}`);
+                }
+            }
+            processing.delete(plugin.manifest.id);
+            visited.add(plugin.manifest.id);
+            sorted.push(plugin);
+        };
+        // First, visit system plugins
+        for (const plugin of plugins) {
+            if (plugin.manifest.system) {
+                visit(plugin);
+            }
+        }
+        // Then visit the rest
+        for (const plugin of plugins) {
+            visit(plugin);
+        }
+        return sorted;
+    }
+    async init() {
+        // if (this.initialized && process.env.NODE_ENV !== "development") return;
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            try {
+                await this.eventBus.publish("system:plugins:init:start", {
+                    timestamp: Date.now(),
+                });
+                // 1. Sync with database
+                const pluginValues = Array.from(this.plugins.values()).map((plugin) => ({
+                    id: plugin.manifest.id,
+                    enabled: plugin.manifest.system ?? false,
+                    installed: plugin.manifest.system ?? false,
+                    system: plugin.manifest.system ?? false,
+                }));
+                if (pluginValues.length > 0) {
+                    try {
+                        await this.repository.seed(pluginValues);
+                    }
+                    catch (_e) {
+                        // Ignore errors if table doesn't exist yet during bootstrap
+                    }
+                }
+                // 2. Fetch current status from DB
+                try {
+                    const dbPlugins = await this.repository.findAll();
+                    for (const dbp of dbPlugins) {
+                        this.pluginStatus.set(dbp.id, {
+                            enabled: dbp.enabled || dbp.system,
+                            installed: dbp.installed || dbp.system,
+                            lastStep: dbp.lastStep,
+                        });
+                    }
+                }
+                catch (_e) {
+                    for (const plugin of this.plugins.values()) {
+                        this.pluginStatus.set(plugin.manifest.id, {
+                            enabled: plugin.manifest.system ?? false,
+                            installed: true,
+                            lastStep: null,
+                        });
+                    }
+                }
+                // 3. Sort plugins by dependencies
+                const sortedPlugins = this.sortPlugins(Array.from(this.plugins.values()));
+                // 4. Initialize enabled plugins
+                for (const plugin of sortedPlugins) {
+                    const status = this.pluginStatus.get(plugin.manifest.id);
+                    if (status?.enabled) {
+                        if (plugin.migrations && plugin.migrations.length > 0) {
+                            await this.migrationRunner.run(plugin.manifest.id, plugin.migrations);
+                        }
+                        if (!status.installed) {
+                            await this.updateStep(plugin.manifest.id, "Installing...");
+                            if (plugin.onMigrate)
+                                await plugin.onMigrate();
+                            if (plugin.onEnable)
+                                await plugin.onEnable();
+                            await this.updateStatus(plugin.manifest.id, {
+                                installed: true,
+                                lastStep: null,
+                            });
+                        }
+                        if (plugin.init)
+                            await plugin.init();
+                    }
+                }
+                this.initialized = true;
+                this.logger.info("veap:plugins", `Initialized with ${this.plugins.size} plugins`);
+                await this.eventBus.publish("system:plugins:init:end", {
+                    timestamp: Date.now(),
+                    pluginCount: this.plugins.size,
+                });
+            }
+            catch (error) {
+                this.initPromise = null;
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    getEnabledPlugins() {
+        return this.getPlugins().filter((p) => {
+            const status = this.pluginStatus.get(p.manifest.id);
+            return status?.enabled ?? false;
+        });
+    }
+    getPlugin(id) {
+        return this.plugins.get(id);
+    }
+    async getPluginsStatus() {
+        try {
+            const dbPlugins = await this.repository.findAll();
+            const dbStatusMap = new Map(dbPlugins.map((p) => [p.id, p]));
+            return this.getPlugins().map((p) => {
+                const dbp = dbStatusMap.get(p.manifest.id);
+                const memStatus = this.pluginStatus.get(p.manifest.id);
+                return {
+                    ...p.manifest,
+                    enabled: dbp?.enabled ?? memStatus?.enabled ?? false,
+                    installed: dbp?.installed ?? memStatus?.installed ?? false,
+                    lastStep: memStatus?.lastStep ?? dbp?.lastStep ?? null,
+                };
+            });
+        }
+        catch (_e) {
+            // Fallback for bootstrap phase
+            return this.getPlugins().map((p) => {
+                const status = this.pluginStatus.get(p.manifest.id);
+                return {
+                    ...p.manifest,
+                    enabled: status?.enabled ?? false,
+                    installed: status?.installed ?? false,
+                    lastStep: status?.lastStep ?? null,
+                };
+            });
+        }
+    }
+    async getPluginStatus(id) {
+        const plugin = this.plugins.get(id);
+        if (!plugin)
+            return null;
+        const memStatus = this.pluginStatus.get(id);
+        const isProcessing = this.processingPlugins.has(id);
+        try {
+            const dbp = await this.repository.findById(id);
+            return {
+                ...plugin.manifest,
+                enabled: dbp?.enabled ?? memStatus?.enabled ?? false,
+                installed: dbp?.installed ?? memStatus?.installed ?? false,
+                // In production, the DB is the only shared truth between processes.
+                // We use DB's lastStep first, then memory, then "Processing..." indicator.
+                lastStep: dbp?.lastStep ??
+                    memStatus?.lastStep ??
+                    (isProcessing ? "Processing..." : null),
+            };
+        }
+        catch (_e) {
+            // Fallback to in-memory if DB fails
+            return {
+                ...plugin.manifest,
+                enabled: memStatus?.enabled ?? false,
+                installed: memStatus?.installed ?? false,
+                lastStep: memStatus?.lastStep ?? (isProcessing ? "Processing..." : null),
+            };
+        }
+    }
+    async getHooks(point) {
+        const hooks = [];
+        for (const plugin of this.getEnabledPlugins()) {
+            if (plugin.hooks) {
+                hooks.push(...plugin.hooks.filter((h) => h.point === point));
+            }
+        }
+        // Items without priority default to 100 to appear later
+        return hooks.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    }
+    async getExtensions(target, point, includeDisabled = false, context) {
+        const extensions = [];
+        const pluginsToScan = includeDisabled
+            ? this.getPlugins()
+            : this.getEnabledPlugins();
+        for (const plugin of pluginsToScan) {
+            if (plugin.extensions) {
+                extensions.push(...plugin.extensions.filter((e) => {
+                    if (e.target !== target || e.point !== point)
+                        return false;
+                    if (context) {
+                        const userRoles = context.roles || [];
+                        const userPermissions = context.permissions || [];
+                        if (e.roles && e.roles.length > 0) {
+                            if (!e.roles.some((role) => userRoles.includes(role))) {
+                                return false;
+                            }
+                        }
+                        if (e.permissions && e.permissions.length > 0) {
+                            if (!e.permissions.every((perm) => userPermissions.includes(perm))) {
+                                return false;
+                            }
+                        }
+                    }
+                    return true;
+                }));
+            }
+        }
+        // Items without priority default to 100 to appear later
+        return extensions.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    }
+    async getWidgets(area, context) {
+        const widgets = [];
+        for (const plugin of this.getEnabledPlugins()) {
+            if (plugin.widgets) {
+                widgets.push(...plugin.widgets.filter((w) => {
+                    if (w.area !== area)
+                        return false;
+                    if (context) {
+                        const userRoles = context.roles || [];
+                        const userPermissions = context.permissions || [];
+                        if (w.roles && w.roles.length > 0) {
+                            if (!w.roles.some((role) => userRoles.includes(role))) {
+                                return false;
+                            }
+                        }
+                        if (w.permissions && w.permissions.length > 0) {
+                            if (!w.permissions.every((perm) => userPermissions.includes(perm))) {
+                                return false;
+                            }
+                        }
+                    }
+                    return true;
+                }));
+            }
+        }
+        // Items without priority default to 100 to appear later
+        return widgets.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    }
+    async delay(ms = 500) {
+        if (process.env.NODE_ENV === "production" ||
+            process.env.VERCEL ||
+            process.env.NEXT_RUNTIME === "edge")
+            return;
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async togglePlugin(id, enabled, context) {
+        const plugin = this.findPlugin(id);
+        if (!plugin)
+            throw AppError.Internal(`Plugin ${id} not found`);
+        // Canonicalize to the registered id so status lookups match
+        id = plugin.manifest.id;
+        const currentStatus = this.pluginStatus.get(id);
+        if (currentStatus?.enabled === enabled)
+            return;
+        // Zapobieganie nieskończonej rekurencji (cyklom zależności)
+        if (this.processingPlugins.has(id)) {
+            return;
+        }
+        this.processingPlugins.add(id);
+        try {
+            if (enabled) {
+                // activation process
+                // 1. Check if the plugin requires any plugins
+                await this.updateStep(id, "Checking dependencies...");
+                await this.delay();
+                const dependencies = plugin.manifest.dependencies || [];
+                // 2. Aktywacja pluginów wymaganych
+                for (const depId of dependencies) {
+                    const depPlugin = this.findPlugin(depId);
+                    const canonicalDepId = depPlugin?.manifest.id ?? resolveDependencyId(depId);
+                    const depStatus = this.pluginStatus.get(canonicalDepId);
+                    if (!depStatus?.enabled) {
+                        const depName = depPlugin?.manifest.name || canonicalDepId;
+                        await this.updateStep(id, `Waiting for dependency activation: ${depName}`);
+                        // Recursive call for dependencies
+                        await this.togglePlugin(canonicalDepId, true, context);
+                        await this.delay();
+                    }
+                }
+                // 3. Before running the onEnable hook, we perform migrations
+                if (plugin.migrations?.length) {
+                    await this.updateStep(id, "Migrating the database...");
+                    await this.delay();
+                    await this.migrationRunner.run(id, plugin.migrations);
+                }
+                // 4. Once migrations are complete, run the onEnable hook
+                if (plugin.onEnable) {
+                    await this.updateStep(id, "Running the onEnable hook...");
+                    await this.delay();
+                    await plugin.onEnable(context);
+                }
+                // 5. Finally, we turn on the plugin
+                await this.updateStatus(id, {
+                    enabled: true,
+                    installed: true,
+                    lastStep: null,
+                });
+                await this.delay();
+            }
+            else {
+                // deactivation process
+                // 1. Check for plugins that depend on us (automatic deactivation "upwards")
+                // We MUST deactivate dependents FIRST, otherwise they would be broken when we disable ourselves
+                // Match both the canonical id and the scoped npm-name form
+                const dependents = Array.from(this.plugins.values()).filter((p) => p.manifest.dependencies?.some((dep) => resolveDependencyId(dep) === resolveDependencyId(id)));
+                for (const dependent of dependents) {
+                    const depStatus = this.pluginStatus.get(dependent.manifest.id);
+                    if (depStatus?.enabled &&
+                        !this.processingPlugins.has(dependent.manifest.id)) {
+                        await this.updateStep(id, `Deactivating dependent plugin: ${dependent.manifest.name}`);
+                        await this.togglePlugin(dependent.manifest.id, false, context);
+                        await this.delay();
+                    }
+                }
+                // 2. Run the onDisable hook
+                if (plugin.onDisable) {
+                    await this.updateStep(id, "Running onDisable hook...");
+                    await this.delay();
+                    await plugin.onDisable();
+                }
+                // 3. Run the rollback migrations
+                if (plugin.migrations?.length) {
+                    await this.updateStep(id, "Rolling back database migrations...");
+                    await this.delay();
+                    try {
+                        await this.migrationRunner.rollback(id, plugin.migrations);
+                    }
+                    catch (e) {
+                        this.logger.error("PluginRegistry", `Rollback failed for ${id}:`, e);
+                    }
+                }
+                // 4. Disable the plugin itself
+                await this.updateStatus(id, { enabled: false, lastStep: null });
+                await this.delay();
+                // 5. Finally, proceed to deactivate unused dependencies
+                const dependencies = plugin.manifest.dependencies || [];
+                for (const depId of dependencies) {
+                    const depPlugin = this.findPlugin(depId);
+                    const canonicalDepId = depPlugin?.manifest.id ?? resolveDependencyId(depId);
+                    const depStatus = this.pluginStatus.get(canonicalDepId);
+                    if (depStatus?.enabled) {
+                        // Check if anyone else is using this dependency (excluding those in the middle of deactivation)
+                        const otherDependents = Array.from(this.plugins.values()).some((p) => p.manifest.id !== id &&
+                            this.pluginStatus.get(p.manifest.id)?.enabled &&
+                            !this.processingPlugins.has(p.manifest.id) &&
+                            p.manifest.dependencies?.some((dep) => resolveDependencyId(dep) ===
+                                resolveDependencyId(canonicalDepId)));
+                        if (!otherDependents) {
+                            const depName = depPlugin?.manifest.name || canonicalDepId;
+                            await this.updateStep(id, `Cleaning up unused dependency: ${depName}`);
+                            await this.togglePlugin(canonicalDepId, false, context);
+                            await this.delay();
+                        }
+                    }
+                }
+            }
+            // Important: init() is only called if we are ENABLING
+            if (enabled && plugin.init)
+                await plugin.init();
+            // Ensure lastStep is cleared at the end of a SUCCESSFUL toggle
+            await this.updateStep(id, null);
+        }
+        catch (error) {
+            this.logger.warn("veap:plugins", `Error toggling plugin ${id}: ${error.message}`);
+            await this.updateStep(id, `Error: ${error.message}`);
+            throw error;
+        }
+        finally {
+            this.processingPlugins.delete(id);
+            // Final safety clear: if we're not in an error state, make sure lastStep is null
+            const finalStatus = this.pluginStatus.get(id);
+            if (finalStatus?.lastStep &&
+                !finalStatus.lastStep.startsWith("Error:") &&
+                !finalStatus.lastStep.includes("...")) {
+                await this.updateStep(id, null);
+            }
+        }
+        await this.eventBus.publish("system:plugin:toggle", {
+            pluginId: id,
+            isEnabled: enabled,
+        });
+    }
+    async hasHooks(point) {
+        for (const plugin of this.getEnabledPlugins()) {
+            if (plugin.hooks?.some((h) => h.point === point))
+                return true;
+        }
+        return false;
+    }
+    async hasExtension(target, point) {
+        for (const plugin of this.getEnabledPlugins()) {
+            if (plugin.extensions) {
+                if (plugin.extensions.some((e) => e.target === target && (point ? e.point === point : true)))
+                    return true;
+            }
+        }
+        return false;
+    }
+    async getConfig(id) {
+        try {
+            const record = await this.repository.findById(id);
+            return record?.config ? JSON.parse(record.config) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async updateConfig(id, config) {
+        try {
+            await this.repository.updateConfig(id, JSON.stringify(config));
+        }
+        catch (_e) { }
+    }
+};
+PluginRegistry = __decorate([
+    Injectable(),
+    __param(0, Inject(PLUGIN_REPOSITORY)),
+    __param(1, Inject(MIGRATION_RUNNER)),
+    __param(2, Inject(LOGGER)),
+    __param(3, Inject(EVENT_BUS)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], PluginRegistry);
+export { PluginRegistry };
+// ─── Backwards-compatible re-exports ─────────────────────────────────────────
+// The implementations live in `facade.ts`; this keeps
+// `export * from "../application/plugins/registry"` in the entry barrels
+// working for all module-level helpers.
+export { applyPluginFilters, ensurePluginsInitialized, getPluginConfig, getPluginStatus, getPluginsStatus, hasPluginExtension, hasPluginHooks, registerPlugins, togglePluginState, updatePluginConfig, } from "./facade";

package/dist/router/discovery.d.ts

@@ -0,0 +1,27 @@
+import { matchRoute } from "./matcher";
+export { matchRoute };
+export declare function getPluginsWithHomepage(): Promise<{
+    id: string;
+    name: string;
+}[]>;
+export { getPluginsWithHomepage as getModulesWithHomepage };
+/**
+ * Builds a unified `RouteTree` from all enabled plugins.
+ *
+ * All trees are merged into a single `RouteTree` instance that can be
+ * passed to the `VeapRouter` component.
+ *
+ * @param includePrivate - If true, includes private routes prefixed with the configured privatePath.\n * @returns A fully merged `RouteTree` instance.
+ */
+export declare const buildRouteTree: (includePrivate?: boolean) => Promise<import("./route-tree").RouteTree>;
+/**
+ * Registers an internal route rewrite rule in RouterService.
+ *
+ * @param from - Incoming public path (e.g. "/logowanie")
+ * @param to - Target virtual path (e.g. "/signin")
+ */
+export declare function addRouteRewrite(from: string, to: string): Promise<void>;
+/**
+ * Returns all registered route rewrites.
+ */
+export declare function getRouteRewrites(): Promise<Map<string, string>>;

package/dist/router/discovery.js

@@ -0,0 +1,37 @@
+import { app } from "@veap/kernel";
+import { cache } from "react";
+import { matchRoute } from "./matcher";
+import { RouterService } from "./router.service";
+export { matchRoute };
+export async function getPluginsWithHomepage() {
+    return (await app(RouterService)).getPluginsWithHomepage();
+}
+export { getPluginsWithHomepage as getModulesWithHomepage };
+/**
+ * Builds a unified `RouteTree` from all enabled plugins.
+ *
+ * All trees are merged into a single `RouteTree` instance that can be
+ * passed to the `VeapRouter` component.
+ *
+ * @param includePrivate - If true, includes private routes prefixed with the configured privatePath.\n * @returns A fully merged `RouteTree` instance.
+ */
+export const buildRouteTree = cache(async (includePrivate = false) => {
+    return (await app(RouterService)).buildRouteTree(includePrivate);
+});
+/**
+ * Registers an internal route rewrite rule in RouterService.
+ *
+ * @param from - Incoming public path (e.g. "/logowanie")
+ * @param to - Target virtual path (e.g. "/signin")
+ */
+export async function addRouteRewrite(from, to) {
+    const router = await app(RouterService);
+    router.addRewrite(from, to);
+}
+/**
+ * Returns all registered route rewrites.
+ */
+export async function getRouteRewrites() {
+    const router = await app(RouterService);
+    return router.getRewrites();
+}

package/dist/router/handler.d.ts

@@ -0,0 +1,6 @@
+import type { RouteTree } from "./route-tree";
+export declare function handleVeapApiRequest(request: Request, { tree, path, searchParams, }: {
+    tree: RouteTree;
+    path: string;
+    searchParams: Record<string, any>;
+}): Promise<Response>;

package/dist/router/handler.js

@@ -0,0 +1,40 @@
+import { ApiEnsuredAuth, runApiPipeline } from "./middlewares";
+import { collectApiMiddlewares, collectAuthRequirements } from "./utils";
+export async function handleVeapApiRequest(request, { tree, path, searchParams, }) {
+    const match = tree.match(path);
+    if (!match) {
+        return new Response(JSON.stringify({ error: "Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    if (!match.isExact || !match.node.route) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed or Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    const method = request.method;
+    const handler = match.node.route[method] || match.node.route[method.toLowerCase()];
+    if (!handler) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+            status: 405,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    const allMiddlewares = collectApiMiddlewares(match.layoutChain, match.node);
+    const auth = collectAuthRequirements(match.layoutChain, match.node);
+    if (auth.needsAuth) {
+        allMiddlewares.unshift(ApiEnsuredAuth);
+    }
+    const context = {
+        params: match.params,
+        searchParams,
+        path,
+        roles: auth.roles.length > 0 ? auth.roles : undefined,
+        permissions: auth.permissions.length > 0 ? auth.permissions : undefined,
+    };
+    return runApiPipeline(allMiddlewares, request, context, async (req, ctx) => {
+        return await handler(req, ctx);
+    });
+}

package/dist/router/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module router
+ * @description Virtual Router API for Veap Plugin system.
+ */
+export { ROUTER_SERVICE, SITE_LAYOUT } from "../common/tokens.js";
+export { addRouteRewrite, buildRouteTree, getModulesWithHomepage, getPluginsWithHomepage, getRouteRewrites, matchRoute, } from "./discovery.js";
+export { handleVeapApiRequest } from "./handler.js";
+export { matchRoute as matchVirtualRoute } from "./matcher.js";
+export { ApiEnsuredAuth, ApiSameOrigin, EnsuredAuth, EnsuredGuest, EnsuredUser, runApiPipeline, runPipeline, SameOrigin, SkipSecurity, } from "./middlewares.js";
+export { RouterErrorBoundary, SoftNavigationInterceptor, VeapRouter, type WithRouterConfig, withRouter, } from "./react/index.js";
+export { extractParamName, isCatchAllSegment, isDynamicSegment, isGroupSegment, isOptionalCatchAllSegment, isParallelSlot, type LayoutChainEntry, type MatchResult, type RouteNode, RouteTree, resolveMagicPrefix, segmentMatchesUrlPart, } from "./route-tree.js";
+export { RouterService } from "./router.service.js";
+export { discoverRoutes, generateRouteManifest, globToTree, } from "./scanner.js";
+export { collectApiMiddlewares, collectAuthRequirements, collectMiddlewares, } from "./utils.js";

package/dist/router/index.js

@@ -0,0 +1,14 @@
+/**
+ * @module router
+ * @description Virtual Router API for Veap Plugin system.
+ */
+export { ROUTER_SERVICE, SITE_LAYOUT } from "../common/tokens.js";
+export { addRouteRewrite, buildRouteTree, getModulesWithHomepage, getPluginsWithHomepage, getRouteRewrites, matchRoute, } from "./discovery.js";
+export { handleVeapApiRequest } from "./handler.js";
+export { matchRoute as matchVirtualRoute } from "./matcher.js";
+export { ApiEnsuredAuth, ApiSameOrigin, EnsuredAuth, EnsuredGuest, EnsuredUser, runApiPipeline, runPipeline, SameOrigin, SkipSecurity, } from "./middlewares.js";
+export { RouterErrorBoundary, SoftNavigationInterceptor, VeapRouter, withRouter, } from "./react/index.js";
+export { extractParamName, isCatchAllSegment, isDynamicSegment, isGroupSegment, isOptionalCatchAllSegment, isParallelSlot, RouteTree, resolveMagicPrefix, segmentMatchesUrlPart, } from "./route-tree.js";
+export { RouterService } from "./router.service.js";
+export { discoverRoutes, generateRouteManifest, globToTree, } from "./scanner.js";
+export { collectApiMiddlewares, collectAuthRequirements, collectMiddlewares, } from "./utils.js";