@veap/plugins 0.0.0-stage → 0.1.0

package/dist/migrations/0001_create_plugins_tables.js

@@ -0,0 +1,29 @@
+export const name = "0001_create_plugins_tables";
+export async function up(_db, schema) {
+    // 1. Plugins table
+    await schema.createTable("plugins", (table) => {
+        table.text("id").primaryKey();
+        table.boolean("enabled").notNull().default(false);
+        table.boolean("installed").notNull().default(false);
+        table.boolean("deleted").notNull().default(false);
+        table.boolean("system").notNull().default(false);
+        table.text("config");
+        table.text("last_step");
+        table.timestamp("updated_at").defaultNow();
+    });
+    // 2. System user widgets table
+    await schema.createTable("system_user_widgets", (table) => {
+        table
+            .text("user_id")
+            .references("users", "id")
+            .onDelete("CASCADE")
+            .notNull();
+        table.text("slot").notNull();
+        table.jsonb("state").notNull().default("[]");
+        table.primary(["user_id", "slot"]);
+    });
+}
+export async function down(_db, schema) {
+    await schema.dropTableIfExists("system_user_widgets");
+    await schema.dropTableIfExists("plugins");
+}

package/dist/migrations/index.d.ts

@@ -0,0 +1,4 @@
+import * as m0001 from "./0001_create_plugins_tables";
+export declare const pluginMigrations: (typeof m0001)[];
+export declare function runPluginMigrations(): Promise<void>;
+export default pluginMigrations;

package/dist/migrations/index.js

@@ -0,0 +1,7 @@
+import { runMigrations } from "@veap/database";
+import * as m0001 from "./0001_create_plugins_tables";
+export const pluginMigrations = [m0001];
+export async function runPluginMigrations() {
+    await runMigrations("plugins", pluginMigrations);
+}
+export default pluginMigrations;

package/dist/models/SystemPlugin.d.ts

@@ -0,0 +1,19 @@
+import { type CastType, Model } from "@veap/database";
+export interface SystemPluginAttributes {
+    id: string;
+    enabled: boolean;
+    installed: boolean;
+    deleted: boolean;
+    system: boolean;
+    config?: string | null;
+    lastStep?: string | null;
+    last_step?: string | null;
+    updatedAt?: Date | null;
+    updated_at?: Date | null;
+}
+export declare class SystemPlugin extends Model<SystemPluginAttributes> {
+    static table: string;
+    static autoUuid: boolean;
+    static timestamps: boolean | string[];
+    static casts: Record<string, CastType>;
+}

package/dist/models/SystemPlugin.js

@@ -0,0 +1,14 @@
+import { Model } from "@veap/database";
+export class SystemPlugin extends Model {
+    static table = "plugins";
+    static autoUuid = false;
+    static timestamps = ["updated_at"];
+    static casts = {
+        enabled: "boolean",
+        installed: "boolean",
+        deleted: "boolean",
+        system: "boolean",
+        updatedAt: "datetime",
+        updated_at: "datetime",
+    };
+}

package/dist/models/SystemUserWidget.d.ts

@@ -0,0 +1,19 @@
+import { User } from "@veap/auth/models";
+import { type CastType, Model } from "@veap/database";
+export interface SystemUserWidgetAttributes {
+    userId: string;
+    user_id?: string;
+    slot: string;
+    state: any;
+}
+export declare class SystemUserWidget extends Model<SystemUserWidgetAttributes> {
+    static table: string;
+    static primaryKey: string;
+    static autoUuid: boolean;
+    static timestamps: boolean;
+    static casts: Record<string, CastType>;
+    /**
+     * Associated user relation.
+     */
+    user(): import("@veap/database").BelongsTo<this, User>;
+}

package/dist/models/SystemUserWidget.js

@@ -0,0 +1,17 @@
+import { User } from "@veap/auth/models";
+import { Model } from "@veap/database";
+export class SystemUserWidget extends Model {
+    static table = "system_user_widgets";
+    static primaryKey = "user_id";
+    static autoUuid = false;
+    static timestamps = false;
+    static casts = {
+        state: "json",
+    };
+    /**
+     * Associated user relation.
+     */
+    user() {
+        return this.belongsTo(User, "user_id");
+    }
+}

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SystemPlugin";
+export * from "./SystemUserWidget";

package/dist/models/index.js

@@ -0,0 +1,2 @@
+export * from "./SystemPlugin";
+export * from "./SystemUserWidget";

package/dist/models.d.ts

@@ -0,0 +1 @@
+export * from "./models/index";

package/dist/models.js

@@ -0,0 +1 @@
+export * from "./models/index";

package/dist/navigation/breadcrumbs.d.ts

@@ -0,0 +1,2 @@
+import type { BreadcrumbItem } from "../common/types";
+export declare function getPluginBreadcrumbs(path: string, searchParams?: any): Promise<BreadcrumbItem[]>;

package/dist/navigation/breadcrumbs.js

@@ -0,0 +1,84 @@
+"use server";
+import { buildRouteTree } from "../router/discovery";
+import { getPluginNavigation, getVeapPluginNavigationGrouped, } from "./navigation.service";
+async function resolveBreadcrumb(value, props) {
+    if (typeof value === "function") {
+        return await value(props);
+    }
+    return value;
+}
+async function findInNavigation(url) {
+    const adminNav = await getVeapPluginNavigationGrouped("admin");
+    const settingsNav = await getVeapPluginNavigationGrouped("settings");
+    const publicNav = await getPluginNavigation("public");
+    const allNavItems = [
+        ...Object.values(adminNav).flat(),
+        ...Object.values(settingsNav).flat(),
+        ...publicNav,
+    ];
+    const search = (items) => {
+        for (const item of items) {
+            if (item.url === url)
+                return item;
+            if (item.items) {
+                const found = search(item.items);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    return search(allNavItems);
+}
+export async function getPluginBreadcrumbs(path, searchParams = {}) {
+    const tree = await buildRouteTree(true);
+    const segments = path.split("/").filter(Boolean);
+    const breadcrumbs = [];
+    let currentPath = "";
+    for (const segment of segments) {
+        currentPath += `/${segment}`;
+        const match = tree.match(currentPath);
+        if (match?.isExact && match?.node?.breadcrumb) {
+            const resolved = await resolveBreadcrumb(match.node.breadcrumb, {
+                params: Promise.resolve(match.params || {}),
+                searchParams: Promise.resolve(searchParams || {}),
+            });
+            addResolvedToBreadcrumbs(resolved, currentPath, breadcrumbs);
+        }
+        else {
+            const navItem = await findInNavigation(currentPath);
+            if (navItem) {
+                breadcrumbs.push({
+                    label: navItem.title,
+                    href: currentPath,
+                    id: navItem.id,
+                });
+            }
+        }
+    }
+    const result = [];
+    const seenHrefs = new Set();
+    for (const bc of breadcrumbs) {
+        if (bc.href && seenHrefs.has(bc.href)) {
+            const index = result.findIndex((r) => r.href === bc.href);
+            if (index !== -1)
+                result[index] = bc;
+            continue;
+        }
+        if (bc.href)
+            seenHrefs.add(bc.href);
+        result.push(bc);
+    }
+    return result.filter((bc) => bc.label);
+}
+function addResolvedToBreadcrumbs(resolved, href, breadcrumbs) {
+    if (Array.isArray(resolved)) {
+        breadcrumbs.push(...resolved);
+    }
+    else if (typeof resolved === "string") {
+        breadcrumbs.push({ label: resolved, href });
+    }
+    else {
+        breadcrumbs.push(resolved);
+    }
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { getPluginBreadcrumbs } from "./breadcrumbs";
+export { getPathPrefix, getPluginNavigation, getPluginNavigationGrouped, getPluginPathPrefix, getVeapPluginNavigationGrouped, NavigationService, } from "./navigation.service";

package/dist/navigation/index.js

@@ -0,0 +1,2 @@
+export { getPluginBreadcrumbs } from "./breadcrumbs";
+export { getPathPrefix, getPluginNavigation, getPluginNavigationGrouped, getPluginPathPrefix, getVeapPluginNavigationGrouped, NavigationService, } from "./navigation.service";

package/dist/navigation/navigation.service.d.ts

@@ -0,0 +1,27 @@
+import { type IVeapConfigProvider } from "@veap/kernel";
+import type { PluginNavElement } from "../common/types";
+import { PluginRegistry } from "../registry";
+/**
+ * Navigation use cases. Depends on the bound plugins context, the auth
+ * context and the config port - no container lookups.
+ */
+export declare class NavigationService {
+    private readonly registry;
+    private readonly config;
+    constructor(registry: PluginRegistry, config: IVeapConfigProvider);
+    getPathPrefix(): Promise<string>;
+    getNavigationGrouped(type: "admin" | "settings"): Promise<{
+        groups: Record<string, PluginNavElement[]>;
+        groupPriorities: Record<string, number>;
+    }>;
+    getVeapNavigationGrouped(type: "admin" | "settings"): Promise<Record<string, PluginNavElement[]>>;
+    getPublicNavigation(): Promise<PluginNavElement[]>;
+}
+export declare function getPathPrefix(): Promise<string>;
+export declare function getPluginPathPrefix(): Promise<string>;
+export declare function getPluginNavigationGrouped(type: "admin" | "settings"): Promise<{
+    groups: Record<string, PluginNavElement[]>;
+    groupPriorities: Record<string, number>;
+}>;
+export declare function getVeapPluginNavigationGrouped(type: "admin" | "settings"): Promise<Record<string, PluginNavElement[]>>;
+export declare function getPluginNavigation(type?: "public"): Promise<PluginNavElement[]>;

package/dist/navigation/navigation.service.js

@@ -0,0 +1,183 @@
+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 { authContext } from "@veap/auth";
+import { Inject, Injectable, VEAP_CONFIG, } from "@veap/kernel";
+import { pluginsContext } from "../common/context";
+import { PluginRegistry } from "../registry";
+function filterNavItem(item, userRoles, userPermissions) {
+    if (item.roles && item.roles.length > 0) {
+        if (!item.roles.some((role) => userRoles.includes(role))) {
+            return null;
+        }
+    }
+    if (item.permissions && item.permissions.length > 0) {
+        if (!item.permissions.every((perm) => userPermissions.includes(perm))) {
+            return null;
+        }
+    }
+    if (item.items && item.items.length > 0) {
+        const filteredSubItems = item.items
+            .map((subItem) => filterNavItem(subItem, userRoles, userPermissions))
+            .filter((subItem) => subItem !== null);
+        return {
+            ...item,
+            items: filteredSubItems,
+        };
+    }
+    return item;
+}
+/**
+ * Navigation use cases. Depends on the bound plugins context, the auth
+ * context and the config port - no container lookups.
+ */
+let NavigationService = class NavigationService {
+    registry;
+    config;
+    constructor(registry, config) {
+        this.registry = registry;
+        this.config = config;
+    }
+    async getPathPrefix() {
+        const config = await this.config.get();
+        return config.privatePath ?? "/app";
+    }
+    async getNavigationGrouped(type) {
+        const { user } = await authContext().session.getCurrentSession();
+        const userRoles = user?.roles || [];
+        const userPermissions = user?.permissions || [];
+        const plugins = this.registry.getEnabledPlugins();
+        const groups = {};
+        const groupPriorities = {};
+        for (const plugin of plugins) {
+            try {
+                const pluginNav = plugin.navigation?.[type];
+                if (pluginNav) {
+                    for (const [groupName, groupData] of Object.entries(pluginNav)) {
+                        if (!groups[groupName])
+                            groups[groupName] = [];
+                        let items = [];
+                        if (Array.isArray(groupData)) {
+                            items = groupData;
+                        }
+                        else {
+                            items = groupData.items;
+                            if (groupData.priority !== undefined &&
+                                (groupPriorities[groupName] === undefined ||
+                                    groupData.priority < groupPriorities[groupName])) {
+                                groupPriorities[groupName] = groupData.priority;
+                            }
+                        }
+                        for (const rawItem of items) {
+                            const item = filterNavItem(rawItem, userRoles, userPermissions);
+                            if (item &&
+                                !groups[groupName].some((existing) => existing.url === item.url)) {
+                                groups[groupName].push(item);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (_e) {
+                console.warn(`[Kernel:Navigation] Failed to load navigation for plugin ${plugin.manifest.id}:`, _e);
+            }
+        }
+        const sortNavItems = (items) => {
+            items.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+            for (const item of items) {
+                if (item.items && item.items.length > 0) {
+                    sortNavItems(item.items);
+                }
+            }
+        };
+        for (const groupName in groups) {
+            sortNavItems(groups[groupName]);
+        }
+        return { groups, groupPriorities };
+    }
+    async getVeapNavigationGrouped(type) {
+        const { groups, groupPriorities } = await this.getNavigationGrouped(type);
+        const prefix = await this.getPathPrefix();
+        const prefixUrl = (url) => {
+            if (url.startsWith(prefix))
+                return url;
+            return url === "/" ? prefix : `${prefix}${url}`;
+        };
+        const processItems = (items) => {
+            return items.map((item) => ({
+                ...item,
+                url: prefixUrl(item.url),
+                items: item.items
+                    ? processItems(item.items)
+                    : undefined,
+            }));
+        };
+        const transformedGroups = {};
+        const sortedGroupNames = Object.keys(groups).sort((a, b) => {
+            const prioA = groupPriorities[a] ?? 1000;
+            const prioB = groupPriorities[b] ?? 1000;
+            if (prioA !== prioB)
+                return prioA - prioB;
+            return a.localeCompare(b);
+        });
+        for (const groupName of sortedGroupNames) {
+            transformedGroups[groupName] = processItems(groups[groupName]);
+        }
+        return transformedGroups;
+    }
+    async getPublicNavigation() {
+        const { user } = await authContext().session.getCurrentSession();
+        const userRoles = user?.roles || [];
+        const userPermissions = user?.permissions || [];
+        const plugins = this.registry.getEnabledPlugins();
+        const all = [];
+        for (const plugin of plugins) {
+            try {
+                if (plugin.navigation?.["public"]) {
+                    const items = plugin.navigation["public"];
+                    for (const rawItem of items) {
+                        const item = filterNavItem(rawItem, userRoles, userPermissions);
+                        if (item)
+                            all.push(item);
+                    }
+                }
+            }
+            catch { }
+        }
+        all.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+        all.sort((a, b) => a.title.localeCompare(b.title));
+        return all;
+    }
+};
+NavigationService = __decorate([
+    Injectable(),
+    __param(0, Inject(PluginRegistry)),
+    __param(1, Inject(VEAP_CONFIG)),
+    __metadata("design:paramtypes", [PluginRegistry, Object])
+], NavigationService);
+export { NavigationService };
+// ─── Module-level API (composition-bound) ───────────────────────────
+export async function getPathPrefix() {
+    return pluginsContext().navigation.getPathPrefix();
+}
+export async function getPluginPathPrefix() {
+    return pluginsContext().navigation.getPathPrefix();
+}
+export async function getPluginNavigationGrouped(type) {
+    return pluginsContext().navigation.getNavigationGrouped(type);
+}
+export async function getVeapPluginNavigationGrouped(type) {
+    return pluginsContext().navigation.getVeapNavigationGrouped(type);
+}
+export async function getPluginNavigation(type = "public") {
+    return pluginsContext().navigation.getPublicNavigation();
+}

package/dist/providers/index.d.ts

@@ -0,0 +1 @@
+export { PluginServiceProvider, type PluginsConfig, PluginsServiceProvider, type RouterConfig, RouterServiceProvider, } from "./plugins.provider";

package/dist/providers/index.js

@@ -0,0 +1 @@
+export { PluginServiceProvider, PluginsServiceProvider, RouterServiceProvider, } from "./plugins.provider";

package/dist/providers/plugins.provider.d.ts

@@ -0,0 +1,20 @@
+import { ServiceProvider } from "@veap/kernel";
+import type * as React from "react";
+export interface PluginsConfig {
+    plugins?: any[];
+    rewrites?: Record<string, string>;
+    siteLayout?: React.ComponentType<any>;
+    /**
+     * Whether to automatically run plugin database migrations during boot().
+     * Defaults to `true` when database connection is initialized.
+     */
+    autoMigrate?: boolean;
+}
+export declare class PluginsServiceProvider extends ServiceProvider {
+    private config?;
+    constructor(container: any, config?: PluginsConfig);
+    register(): void;
+    boot(): Promise<void>;
+}
+export type { PluginsConfig as RouterConfig };
+export { PluginsServiceProvider as PluginServiceProvider, PluginsServiceProvider as RouterServiceProvider, };

package/dist/providers/plugins.provider.js

@@ -0,0 +1,142 @@
+import { isDatabaseInitialized } from "@veap/database";
+import { IntlService } from "@veap/intl/server";
+import { APP_PLUGINS, eventBus, ROUTER_SERVICE, ServiceProvider, SITE_LAYOUT, } from "@veap/kernel";
+import { bindPluginsContext } from "../common/context";
+import { runPluginMigrations } from "../migrations";
+import { NavigationService } from "../navigation/navigation.service";
+import { MIGRATION_RUNNER, PLUGIN_REPOSITORY } from "../registry/contracts";
+import { ensurePluginsInitialized, registerPlugins } from "../registry/facade";
+import { KnexMigrationRunner } from "../registry/migration-runner";
+import { ActiveRecordPluginRepository } from "../registry/plugin.repository";
+import { PluginRegistry } from "../registry/registry.service";
+import { RouterService } from "../router/router.service";
+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, };