@unchainedshop/api 4.8.26 → 4.8.27

package/lib/adminUiPlugins.d.ts

@@ -0,0 +1,97 @@
+export interface AdminUIThemeTokens {
+    surface?: string;
+    'surface-subtle'?: string;
+    'surface-raised'?: string;
+    'surface-input'?: string;
+    border?: string;
+    'border-subtle'?: string;
+    'text-primary'?: string;
+    'text-secondary'?: string;
+    'text-muted'?: string;
+    'text-on-dark'?: string;
+    accent?: string;
+    'accent-hover'?: string;
+    danger?: string;
+    'danger-surface'?: string;
+    success?: string;
+    warning?: string;
+    'focus-ring'?: string;
+    'text-on-accent'?: string;
+}
+export interface AdminUIThemeConfig {
+    light?: AdminUIThemeTokens;
+    dark?: AdminUIThemeTokens;
+}
+export interface AdminUIPluginEntityConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    components: {
+        list: string;
+        detail: string;
+        create?: string;
+    };
+}
+export interface AdminUIPluginPageConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    component: string;
+}
+export interface AdminUIPluginTabConfig {
+    label: string;
+    component: string;
+    requiredRole?: string;
+}
+export interface AdminUIPluginWidgetConfig {
+    component: string;
+    width?: 'full' | 'half' | 'third';
+}
+export interface AdminUIPluginSlotConfig {
+    component: string;
+}
+export interface AdminUIPluginConfig {
+    name: string;
+    version?: string;
+    bundlePath: string;
+    navigation?: {
+        label: string;
+        icon?: string;
+        requiredRole?: string;
+        sortOrder?: number;
+    };
+    slots: {
+        entities?: AdminUIPluginEntityConfig[];
+        pages?: AdminUIPluginPageConfig[];
+        'dashboard:widgets'?: AdminUIPluginWidgetConfig[];
+        'product:tabs'?: AdminUIPluginTabConfig[];
+        'assortment:tabs'?: AdminUIPluginTabConfig[];
+        'filter:tabs'?: AdminUIPluginTabConfig[];
+        'user:tabs'?: AdminUIPluginTabConfig[];
+        'order:tabs'?: AdminUIPluginTabConfig[];
+        [key: string]: AdminUIPluginTabConfig[] | AdminUIPluginSlotConfig[] | AdminUIPluginEntityConfig[] | AdminUIPluginPageConfig[] | AdminUIPluginWidgetConfig[] | undefined;
+    };
+}
+interface StaticAsset {
+    content: string | (() => string);
+    contentType: string;
+    cacheControl: string;
+    etag?: string;
+}
+export interface PreparedPluginAssets {
+    routes: Map<string, StaticAsset>;
+    validPlugins: AdminUIPluginConfig[];
+}
+export declare const resolveAdminUIPath: () => string | null;
+export declare const parseBundleExports: (bundle: string) => Set<string> | null;
+export declare function preparePluginAssets(plugins: AdminUIPluginConfig[], log: {
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+}, options?: {
+    devMode?: boolean;
+}): PreparedPluginAssets;
+export {};

package/lib/adminUiPlugins.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+const PLUGIN_NAME_RE = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9_-]*[a-z0-9])?)*$/i;
+const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable';
+export const resolveAdminUIPath = () => {
+    try {
+        const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+        return new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+    }
+    catch {
+        return null;
+    }
+};
+const contentHash = (content) => createHash('sha256').update(content).digest('hex').slice(0, 8);
+export const parseBundleExports = (bundle) => {
+    const returnMatch = bundle.match(/return __toCommonJS\(([\w$]+)\);/);
+    if (!returnMatch)
+        return null;
+    const blockMatch = bundle.match(new RegExp(`__export\\(${returnMatch[1].replace(/\$/g, '\\$')},\\s*\\{([\\s\\S]*?)\\}\\);`));
+    if (!blockMatch)
+        return null;
+    const names = new Set();
+    for (const m of blockMatch[1].matchAll(/(?:^|,)\s*(?:"([^"]+)"|([\w$]+)):\s*\(\)\s*=>/g)) {
+        names.add(m[1] ?? m[2]);
+    }
+    return names.size > 0 ? names : null;
+};
+const collectReferencedComponents = (plugin) => {
+    const names = new Set();
+    for (const [slotId, configs] of Object.entries(plugin.slots || {})) {
+        if (!Array.isArray(configs))
+            continue;
+        for (const config of configs) {
+            if (slotId === 'entities') {
+                const components = config.components;
+                if (components?.list)
+                    names.add(components.list);
+                if (components?.detail)
+                    names.add(components.detail);
+                if (components?.create)
+                    names.add(components.create);
+            }
+            else if (typeof config.component === 'string') {
+                names.add(config.component);
+            }
+        }
+    }
+    return [...names];
+};
+export function preparePluginAssets(plugins, log, options = {}) {
+    const { devMode = false } = options;
+    const routes = new Map();
+    const devCacheControl = 'no-cache, no-store, must-revalidate';
+    const validPlugins = plugins.filter((p) => {
+        if (!PLUGIN_NAME_RE.test(p.name)) {
+            log.warn(`Skipping admin-ui plugin with invalid name: "${p.name}"`);
+            return false;
+        }
+        return true;
+    });
+    const seenNames = new Set();
+    for (const plugin of validPlugins) {
+        if (seenNames.has(plugin.name)) {
+            log.warn(`Duplicate admin-ui plugin name "${plugin.name}": later entries override earlier ones`);
+        }
+        seenNames.add(plugin.name);
+    }
+    if (validPlugins.length > 0) {
+        const pluginList = validPlugins
+            .map((p) => `${p.name}${p.version ? `@${p.version}` : ''}`)
+            .join(', ');
+        log.info(`Loading ${validPlugins.length} admin-ui plugin(s): ${pluginList}`);
+    }
+    const resolvedBundlePaths = new Map();
+    const pluginBundles = new Map();
+    for (const plugin of validPlugins) {
+        try {
+            const bundlePath = resolve(plugin.bundlePath);
+            const content = readFileSync(bundlePath, 'utf-8');
+            resolvedBundlePaths.set(plugin.name, bundlePath);
+            pluginBundles.set(plugin.name, { content, hash: contentHash(content) });
+        }
+        catch (err) {
+            log.warn(`Failed to read bundle for plugin "${plugin.name}" at ${plugin.bundlePath}: ${err.message}`);
+        }
+    }
+    const pluginsWithBundles = validPlugins.filter((p) => pluginBundles.has(p.name));
+    for (const plugin of pluginsWithBundles) {
+        const exportNames = parseBundleExports(pluginBundles.get(plugin.name).content);
+        if (!exportNames)
+            continue;
+        const missing = collectReferencedComponents(plugin).filter((name) => !exportNames.has(name));
+        if (missing.length > 0) {
+            log.warn(`admin-ui plugin "${plugin.name}" references component(s) not exported by its bundle: ${missing.join(', ')}. Exported: ${[...exportNames].join(', ')}`);
+        }
+    }
+    const bundleMtimes = new Map();
+    const bundleHashes = new Map();
+    for (const [name, bundle] of pluginBundles) {
+        bundleHashes.set(name, bundle.hash);
+        try {
+            bundleMtimes.set(name, statSync(resolvedBundlePaths.get(name)).mtimeMs);
+        }
+        catch {
+        }
+    }
+    const refreshBundleHash = (name) => {
+        const bundlePath = resolvedBundlePaths.get(name);
+        try {
+            const currentMtime = statSync(bundlePath).mtimeMs;
+            const cachedMtime = bundleMtimes.get(name);
+            if (cachedMtime !== undefined && cachedMtime === currentMtime) {
+                return bundleHashes.get(name);
+            }
+            const hash = contentHash(readFileSync(bundlePath, 'utf-8'));
+            bundleMtimes.set(name, currentMtime);
+            bundleHashes.set(name, hash);
+            return hash;
+        }
+        catch {
+            return bundleHashes.get(name) ?? pluginBundles.get(name).hash;
+        }
+    };
+    const buildManifestJSON = () => JSON.stringify(pluginsWithBundles.map((plugin) => ({
+        ...Object.fromEntries(Object.entries(plugin).filter(([k]) => k !== 'bundlePath')),
+        bundleUrl: `/admin-plugins/${plugin.name}.js?v=${devMode ? refreshBundleHash(plugin.name) : pluginBundles.get(plugin.name).hash}`,
+    })));
+    if (devMode) {
+        routes.set('/admin-ui-plugins.json', {
+            content: buildManifestJSON,
+            contentType: 'application/json',
+            cacheControl: devCacheControl,
+        });
+    }
+    else {
+        const manifestJSON = buildManifestJSON();
+        routes.set('/admin-ui-plugins.json', {
+            content: manifestJSON,
+            contentType: 'application/json',
+            cacheControl: 'public, max-age=0, must-revalidate',
+            etag: `"${contentHash(manifestJSON)}"`,
+        });
+    }
+    for (const plugin of pluginsWithBundles) {
+        const bundlePath = resolvedBundlePaths.get(plugin.name);
+        if (devMode) {
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content: () => readFileSync(bundlePath, 'utf-8'),
+                contentType: 'application/javascript',
+                cacheControl: devCacheControl,
+            });
+        }
+        else {
+            const { content } = pluginBundles.get(plugin.name);
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content,
+                contentType: 'application/javascript',
+                cacheControl: IMMUTABLE_CACHE,
+            });
+        }
+    }
+    return { routes, validPlugins };
+}

package/lib/auth.d.ts

@@ -0,0 +1,36 @@
+export interface AccessTokenPayload {
+    iss: string;
+    sub: string;
+    ver: number;
+    imp?: string;
+    jti?: string;
+    iat?: number;
+    exp?: number;
+}
+export interface OIDCProviderConfig {
+    issuer: string;
+    jwksUri?: string;
+    audience?: string | string[];
+}
+export interface AuthConfig {
+    oidcProviders?: OIDCProviderConfig[];
+}
+export declare function signAccessToken(userId: string, tokenVersion: number, options?: {
+    impersonatorId?: string;
+}): Promise<{
+    token: string;
+    expires: Date;
+}>;
+export declare function verifyLocalToken(token: string): Promise<AccessTokenPayload | null>;
+export declare function verifyOIDCToken(token: string, providers: OIDCProviderConfig[]): Promise<{
+    userId: string;
+    roles?: string[];
+} | null>;
+export interface AuthHandlerResult {
+    userId?: string;
+    tokenVersion?: number;
+    impersonatorId?: string;
+    accessToken?: string;
+    isApiKey?: boolean;
+}
+export declare function createAuthHandler(config?: AuthConfig): (token: string) => Promise<AuthHandlerResult>;

package/lib/auth.js

@@ -0,0 +1,167 @@
+import { createLogger } from '@unchainedshop/logger';
+import * as jose from 'jose';
+const logger = createLogger('unchained:api:auth');
+const { UNCHAINED_TOKEN_SECRET, UNCHAINED_TOKEN_EXPIRY_SECONDS = '3600', UNCHAINED_TOKEN_ISSUER = 'unchained-engine', } = process.env;
+const MIN_SECRET_LENGTH = 32;
+const jwksCache = new Map();
+function validateSecretStrength(secret) {
+    if (secret.length < MIN_SECRET_LENGTH) {
+        throw new Error(`UNCHAINED_TOKEN_SECRET must be at least ${MIN_SECRET_LENGTH} characters (256 bits) for security. ` +
+            `Current length: ${secret.length}. Generate a secure secret with: node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"`);
+    }
+}
+export async function signAccessToken(userId, tokenVersion, options) {
+    if (!UNCHAINED_TOKEN_SECRET) {
+        throw new Error('UNCHAINED_TOKEN_SECRET environment variable is required');
+    }
+    validateSecretStrength(UNCHAINED_TOKEN_SECRET);
+    const expirySeconds = parseInt(UNCHAINED_TOKEN_EXPIRY_SECONDS, 10);
+    const now = Math.floor(Date.now() / 1000);
+    const payload = {
+        sub: userId,
+        ver: tokenVersion,
+        jti: crypto.randomUUID(),
+    };
+    if (options?.impersonatorId) {
+        payload.imp = options.impersonatorId;
+    }
+    const secret = new TextEncoder().encode(UNCHAINED_TOKEN_SECRET);
+    const token = await new jose.SignJWT(payload)
+        .setProtectedHeader({ alg: 'HS256' })
+        .setIssuedAt(now)
+        .setIssuer(UNCHAINED_TOKEN_ISSUER)
+        .setExpirationTime(now + expirySeconds)
+        .sign(secret);
+    const expires = new Date((now + expirySeconds) * 1000);
+    return { token, expires };
+}
+export async function verifyLocalToken(token) {
+    if (!UNCHAINED_TOKEN_SECRET) {
+        logger.warn('UNCHAINED_TOKEN_SECRET not set, cannot verify local tokens');
+        return null;
+    }
+    try {
+        validateSecretStrength(UNCHAINED_TOKEN_SECRET);
+        const secret = new TextEncoder().encode(UNCHAINED_TOKEN_SECRET);
+        const { payload } = await jose.jwtVerify(token, secret, {
+            algorithms: ['HS256'],
+            issuer: UNCHAINED_TOKEN_ISSUER,
+        });
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof jose.errors.JWTExpired) {
+            logger.debug('Token expired');
+        }
+        else if (error instanceof jose.errors.JWTInvalid ||
+            error instanceof jose.errors.JWSInvalid ||
+            error instanceof jose.errors.JWSSignatureVerificationFailed ||
+            error instanceof jose.errors.JWTClaimValidationFailed) {
+            logger.debug('Invalid token signature or claims');
+        }
+        else {
+            logger.error('Token verification error:', {
+                message: error.message,
+                name: error.name,
+            });
+        }
+        return null;
+    }
+}
+function getJWKS(jwksUri) {
+    let jwks = jwksCache.get(jwksUri);
+    if (!jwks) {
+        jwks = jose.createRemoteJWKSet(new URL(jwksUri), {
+            cooldownDuration: 30000,
+            cacheMaxAge: 600000,
+        });
+        jwksCache.set(jwksUri, jwks);
+    }
+    return jwks;
+}
+export async function verifyOIDCToken(token, providers) {
+    let decodedPayload;
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            logger.debug('Invalid JWT format');
+            return null;
+        }
+        decodedPayload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
+    }
+    catch {
+        logger.debug('Failed to decode JWT');
+        return null;
+    }
+    const { iss, sub } = decodedPayload;
+    if (!iss || !sub || typeof iss !== 'string' || typeof sub !== 'string') {
+        logger.debug('OIDC token missing issuer or subject');
+        return null;
+    }
+    const provider = providers.find((p) => p.issuer === iss);
+    if (!provider) {
+        logger.debug('No matching OIDC provider for issuer:', { iss });
+        return null;
+    }
+    const jwksUri = provider.jwksUri || `${provider.issuer}/.well-known/jwks.json`;
+    try {
+        const JWKS = getJWKS(jwksUri);
+        const verifyOptions = {
+            issuer: provider.issuer,
+        };
+        if (provider.audience) {
+            verifyOptions.audience = provider.audience;
+        }
+        const { payload } = await jose.jwtVerify(token, JWKS, verifyOptions);
+        logger.debug('OIDC token verified successfully', { issuer: iss, subject: sub });
+        return {
+            userId: payload.sub,
+            roles: payload.roles,
+        };
+    }
+    catch (error) {
+        if (error instanceof jose.errors.JWTExpired) {
+            logger.debug('OIDC token expired');
+        }
+        else if (error instanceof jose.errors.JWTClaimValidationFailed) {
+            logger.debug('OIDC token claim validation failed:', { message: error.message });
+        }
+        else if (error instanceof jose.errors.JWSSignatureVerificationFailed) {
+            logger.debug('OIDC token signature verification failed');
+        }
+        else {
+            logger.error('OIDC token verification failed:', {
+                message: error.message,
+                name: error.name,
+            });
+        }
+        return null;
+    }
+}
+export function createAuthHandler(config) {
+    return async function verifyToken(token) {
+        if (!token) {
+            return {};
+        }
+        const localPayload = await verifyLocalToken(token);
+        if (localPayload) {
+            return {
+                userId: localPayload.sub,
+                tokenVersion: localPayload.ver,
+                impersonatorId: localPayload.imp,
+            };
+        }
+        if (config?.oidcProviders?.length) {
+            const oidcResult = await verifyOIDCToken(token, config.oidcProviders);
+            if (oidcResult) {
+                return {
+                    userId: oidcResult.userId,
+                };
+            }
+        }
+        return {
+            accessToken: token,
+            isApiKey: true,
+        };
+    };
+}

package/lib/express/mountPluginRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function mountPluginRoutes(app: Express, unchainedAPI: UnchainedCore): void;

package/lib/express/mountPluginRoutes.js

@@ -0,0 +1,59 @@
+import { pluginRegistry } from '@unchainedshop/core';
+import { createServerAdapter } from '@whatwg-node/server';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('express');
+export function mountPluginRoutes(app, unchainedAPI) {
+    const routes = pluginRegistry.getRoutes();
+    if (routes.length > 0) {
+        const endpoints = routes.map((r) => `${r.method} ${r.path}`).join(', ');
+        logger.info(`Mounting ${routes.length} plugin route(s): ${endpoints}`);
+    }
+    for (const route of routes) {
+        const adapter = createServerAdapter(async (request, serverContext) => {
+            const context = {
+                ...unchainedAPI,
+                ...serverContext.unchainedContext,
+                params: serverContext.params || {},
+                rawRequest: serverContext.rawRequest,
+            };
+            try {
+                return await route.handler(request, context);
+            }
+            catch (error) {
+                logger.error(`Error in plugin route handler ${route.method} ${route.path}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return new Response(JSON.stringify({
+                    error: error instanceof Error ? error.message : 'Internal Server Error',
+                }), {
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        });
+        const method = route.method.toLowerCase();
+        const expressHandler = async (req, res) => {
+            try {
+                await adapter.handleNodeRequestAndResponse(req, res, {
+                    unchainedContext: req.unchainedContext,
+                    params: req.params,
+                    rawRequest: req,
+                });
+            }
+            catch (error) {
+                logger.error(`Error handling request for ${route.method} ${route.path}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (!res.headersSent) {
+                    res.status(500).json({ error: 'Internal Server Error' });
+                }
+            }
+        };
+        if (method === 'all') {
+            app.use(route.path, expressHandler);
+        }
+        else {
+            app[method](route.path, expressHandler);
+        }
+    }
+}

package/lib/express/mountRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { UnchainedCore, PluginHttpRoute } from '@unchainedshop/core';
+export declare function mountRoutes(app: Express, unchainedAPI: UnchainedCore, routes: PluginHttpRoute[]): void;

package/lib/express/mountRoutes.js

@@ -0,0 +1,57 @@
+import { createServerAdapter } from '@whatwg-node/server';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('express');
+export function mountRoutes(app, unchainedAPI, routes) {
+    if (routes.length === 0)
+        return;
+    const endpoints = routes.map((r) => `${r.method} ${r.path}`).join(', ');
+    logger.info(`Mounting ${routes.length} route(s): ${endpoints}`);
+    for (const route of routes) {
+        const adapter = createServerAdapter(async (request, serverContext) => {
+            const context = {
+                ...unchainedAPI,
+                ...serverContext.unchainedContext,
+                params: serverContext.params || {},
+                rawRequest: serverContext.rawRequest,
+            };
+            try {
+                return await route.handler(request, context);
+            }
+            catch (error) {
+                logger.error(`Error in route handler ${route.method} ${route.path}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return new Response(JSON.stringify({
+                    error: error instanceof Error ? error.message : 'Internal Server Error',
+                }), {
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        });
+        const method = route.method.toLowerCase();
+        const expressHandler = async (req, res) => {
+            try {
+                await adapter.handleNodeRequestAndResponse(req, res, {
+                    unchainedContext: req.unchainedContext,
+                    params: req.params,
+                    rawRequest: req,
+                });
+            }
+            catch (error) {
+                logger.error(`Error handling request for ${route.method} ${route.path}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (!res.headersSent) {
+                    res.status(500).json({ error: 'Internal Server Error' });
+                }
+            }
+        };
+        if (method === 'all') {
+            app.use(route.path, expressHandler);
+        }
+        else {
+            app[method](route.path, expressHandler);
+        }
+    }
+}

package/lib/fastify/mountPluginRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function mountPluginRoutes(fastify: FastifyInstance, unchainedAPI: UnchainedCore): void;

package/lib/fastify/mountPluginRoutes.js

@@ -0,0 +1,62 @@
+import { pluginRegistry } from '@unchainedshop/core';
+import { createServerAdapter } from '@whatwg-node/server';
+export function mountPluginRoutes(fastify, unchainedAPI) {
+    const routes = pluginRegistry.getRoutes();
+    if (routes.length === 0)
+        return;
+    const endpoints = routes.map((r) => `${r.method} ${r.path}`).join(', ');
+    fastify.log.info(`Mounting ${routes.length} plugin route(s): ${endpoints}`);
+    fastify.register((scope, opts, registered) => {
+        scope.removeAllContentTypeParsers();
+        scope.addContentTypeParser('*', function (request, payload, done) {
+            done(null);
+        });
+        for (const route of routes) {
+            const adapter = createServerAdapter(async (request, serverContext) => {
+                const context = {
+                    ...unchainedAPI,
+                    ...serverContext.unchainedContext,
+                    params: serverContext.params || {},
+                    rawRequest: serverContext.rawRequest,
+                };
+                try {
+                    return await route.handler(request, context);
+                }
+                catch (error) {
+                    fastify.log.error(`Error in plugin route handler ${route.method} ${route.path}: ${error instanceof Error ? error.message : String(error)}`);
+                    return new Response(JSON.stringify({
+                        error: error instanceof Error ? error.message : 'Internal Server Error',
+                    }), {
+                        status: 500,
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+            });
+            let methods;
+            if (route.method === 'ALL') {
+                methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];
+            }
+            else {
+                methods = [route.method];
+            }
+            scope.route({
+                url: route.path,
+                method: methods,
+                handler: async (req, reply) => {
+                    const response = await adapter.handleNodeRequestAndResponse(req.raw, reply.raw, {
+                        unchainedContext: req.unchainedContext,
+                        params: req.params,
+                        rawRequest: req.raw,
+                    });
+                    response.headers.forEach((value, key) => {
+                        reply.header(key, value);
+                    });
+                    reply.status(response.status);
+                    reply.send(response.body || undefined);
+                    return reply;
+                },
+            });
+        }
+        registered();
+    });
+}

package/lib/fastify/mountRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { UnchainedCore, PluginHttpRoute } from '@unchainedshop/core';
+export declare function mountRoutes(fastify: FastifyInstance, unchainedAPI: UnchainedCore, routes: PluginHttpRoute[]): void;