@veap/plugins 0.0.0-stage → 0.1.1

package/dist/common/types.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const PluginManifestSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    dependencies: z.array(z.string()).default([]),
+    extends: z.array(z.string()).default([]),
+    enabled: z.boolean().default(true),
+    system: z.boolean().default(false),
+    hasSetup: z.boolean().default(false),
+    author: z.string().optional(),
+});
+/**
+ * Helper to build a `PluginManifest` from a `package.json` import.\n * Eliminates the need for a standalone `manifest.json` file.
+ *
+ * @example
+ * ```ts
+ * import pkg from "../package.json" with { type: "json" };
+ * import { createManifestFromPackageJson } from "@veap/framework/plugins";
+ * const manifest = createManifestFromPackageJson(pkg);
+ * ```
+ */
+export function createManifestFromPackageJson(pkg) {
+    const meta = pkg.veap || {};
+    return {
+        id: meta.id || pkg.name.replace(/^@[^/]+\//, ""),
+        name: meta.name || pkg.name,
+        version: pkg.version,
+        description: meta.description || pkg.description,
+        enabled: meta.enabled ?? true,
+        system: meta.system ?? false,
+        hasSetup: meta.hasSetup ?? false,
+        dependencies: meta.dependencies || [],
+        extends: meta.extends || [],
+        isNpm: meta.isNpm ?? true,
+        author: meta.author,
+    };
+}

package/dist/composition.d.ts

@@ -0,0 +1,15 @@
+import { ServiceProvider } from "@veap/kernel";
+declare module "@veap/kernel" {
+    interface ApplicationBuilder {
+        /**
+         * Registers plugins with the application IoC container and configures PluginsServiceProvider.
+         */
+        withPlugins(plugins: any[]): this;
+    }
+}
+declare class PluginsConfigProvider extends ServiceProvider {
+    private plugins;
+    constructor(container: any, plugins?: any[]);
+    register(): void;
+}
+export { PluginsConfigProvider };

package/dist/composition.js

@@ -0,0 +1,20 @@
+import { ApplicationBuilder, ServiceProvider } from "@veap/kernel";
+import { APP_PLUGINS } from "./common/tokens.js";
+import { PluginsServiceProvider } from "./providers/plugins.provider.js";
+class PluginsConfigProvider extends ServiceProvider {
+    plugins;
+    constructor(container, plugins = []) {
+        super(container);
+        this.plugins = plugins;
+    }
+    register() {
+        this.container.register({ token: APP_PLUGINS, useValue: this.plugins });
+        this.container.register({ token: "AppPlugins", useValue: this.plugins });
+    }
+}
+if (!ApplicationBuilder.prototype.withPlugins) {
+    ApplicationBuilder.prototype.withPlugins = function (plugins) {
+        return this.use((c) => new PluginsConfigProvider(c, plugins)).use(PluginsServiceProvider);
+    };
+}
+export { PluginsConfigProvider };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./common/index.js";
+export * from "./composition.js";
+export * from "./migrations/index.js";
+export * from "./navigation/index.js";
+export * from "./providers/index.js";
+export * from "./registry/index.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./common/index.js";
+export * from "./composition.js";
+export * from "./migrations/index.js";
+export * from "./navigation/index.js";
+export * from "./providers/index.js";
+export * from "./registry/index.js";

package/dist/migrations/0001_create_plugins_tables.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "@veap/database";
+export declare const name = "0001_create_plugins_tables";
+export declare function up(_db: any, schema: Schema): Promise<void>;
+export declare function down(_db: any, schema: Schema): Promise<void>;

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