@taujs/server 0.4.0 → 0.4.2

package/dist/Config-BuUuMjmO.d.ts

@@ -0,0 +1,209 @@
+import { FastifyRequest } from 'fastify';
+import { PluginOption } from 'vite';
+
+declare const DEBUG_CATEGORIES: readonly ["auth", "routes", "errors", "vite", "network", "ssr"];
+type DebugCategory = (typeof DEBUG_CATEGORIES)[number];
+type DebugConfig = boolean | DebugCategory[] | ({
+    all?: boolean;
+} & Partial<Record<DebugCategory, boolean>>);
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface BaseLogger {
+    debug?(meta?: Record<string, unknown>, message?: string): void;
+    info?(meta?: Record<string, unknown>, message?: string): void;
+    warn?(meta?: Record<string, unknown>, message?: string): void;
+    error?(meta?: Record<string, unknown>, message?: string): void;
+    child?(context: Record<string, unknown>): BaseLogger;
+}
+interface Logs extends BaseLogger {
+    debug(meta?: unknown, message?: string): void;
+    debug(category: DebugCategory, meta?: unknown, message?: string): void;
+    info(meta?: unknown, message?: string): void;
+    warn(meta?: unknown, message?: string): void;
+    error(meta?: unknown, message?: string): void;
+    child(context: Record<string, unknown>): Logs;
+    isDebugEnabled(category: DebugCategory): boolean;
+}
+declare class Logger implements Logs {
+    private config;
+    private debugEnabled;
+    private context;
+    constructor(config?: {
+        custom?: BaseLogger;
+        context?: Record<string, unknown>;
+        minLevel?: LogLevel;
+        includeStack?: boolean | ((level: LogLevel) => boolean);
+        includeContext?: boolean | ((level: LogLevel) => boolean);
+        singleLine?: boolean;
+    });
+    child(context: Record<string, unknown>): Logger;
+    configure(debug?: DebugConfig): void;
+    isDebugEnabled(category: DebugCategory): boolean;
+    private shouldEmit;
+    private shouldIncludeStack;
+    private stripStacks;
+    private formatTimestamp;
+    private emit;
+    info(meta?: unknown, message?: string): void;
+    warn(meta?: unknown, message?: string): void;
+    error(meta?: unknown, message?: string): void;
+    debug(category: DebugCategory, meta?: unknown, message?: string): void;
+}
+declare function createLogger(opts?: {
+    debug?: DebugConfig | string | boolean;
+    custom?: BaseLogger;
+    context?: Record<string, unknown>;
+    minLevel?: LogLevel;
+    includeStack?: boolean | ((level: LogLevel) => boolean);
+    includeContext?: boolean | ((level: LogLevel) => boolean);
+    singleLine?: boolean;
+}): Logger;
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [k: string]: JsonValue;
+};
+type JsonObject = {
+    [k: string]: JsonValue;
+};
+type NarrowSchema<T> = {
+    parse: (u: unknown) => T;
+} | ((u: unknown) => T);
+type ServiceContext = {
+    signal?: AbortSignal;
+    deadlineMs?: number;
+    traceId?: string;
+    logger?: Logs;
+    user?: {
+        id: string;
+        roles: string[];
+    } | null;
+};
+type ServiceMethod<P, R extends JsonObject = JsonObject> = (params: P, ctx: ServiceContext) => Promise<R>;
+type ServiceDefinition = Readonly<Record<string, ServiceMethod<any, JsonObject>>>;
+type ServiceRegistry = Readonly<Record<string, ServiceDefinition>>;
+type ServiceDescriptor = {
+    serviceName: string;
+    serviceMethod: string;
+    args?: JsonObject;
+};
+declare function defineService<T extends Record<string, ServiceMethod<any, JsonObject> | {
+    handler: ServiceMethod<any, JsonObject>;
+    params?: NarrowSchema<any>;
+    result?: NarrowSchema<any>;
+}>>(spec: T): { [K in keyof T]: T[K] extends ServiceMethod<infer P, infer R> ? ServiceMethod<P, R> : T[K] extends {
+    handler: ServiceMethod<infer P, infer R_1>;
+} ? ServiceMethod<P, R_1> : never; };
+declare const defineServiceRegistry: <R extends ServiceRegistry>(registry: R) => R;
+
+type RequestContext<L extends Logs = Logs> = {
+    traceId: string;
+    logger: L;
+    headers: Record<string, string>;
+};
+
+type RouteCSPConfig = {
+    disabled?: boolean;
+    mode?: 'merge' | 'replace';
+    directives?: CSPDirectives | ((args: {
+        url: string;
+        params: PathToRegExpParams;
+        headers: FastifyRequest['headers'];
+        req: FastifyRequest;
+    }) => CSPDirectives);
+    generateCSP?: (directives: CSPDirectives, nonce: string, req: FastifyRequest) => string;
+    reportOnly?: boolean;
+};
+type BaseMiddleware = {
+    auth?: {
+        redirect?: string;
+        roles?: string[];
+        strategy?: string;
+    };
+    csp?: RouteCSPConfig | false;
+};
+type DataResult = Record<string, unknown> | ServiceDescriptor;
+type DataHandler<Params extends PathToRegExpParams, L extends Logs = Logs> = (params: Params, ctx: RequestContext<L> & {
+    [key: string]: unknown;
+}) => Promise<DataResult>;
+type PathToRegExpParams = Partial<Record<string, string | string[]>>;
+type RouteAttributes<Params extends PathToRegExpParams = PathToRegExpParams, Middleware = BaseMiddleware, L extends Logs = Logs> = {
+    render: 'ssr';
+    hydrate?: boolean;
+    meta?: Record<string, unknown>;
+    middleware?: Middleware;
+    data?: DataHandler<Params, L>;
+} | {
+    render: 'streaming';
+    hydrate?: boolean;
+    meta: Record<string, unknown>;
+    middleware?: Middleware;
+    data?: DataHandler<Params, L>;
+};
+type Route<Params extends PathToRegExpParams = PathToRegExpParams> = {
+    attr?: RouteAttributes<Params>;
+    path: string;
+    appId?: string;
+};
+interface InitialRouteParams extends Record<string, unknown> {
+    serviceName?: string;
+    serviceMethod?: string;
+}
+
+type CSPDirectives = Record<string, string[]>;
+
+type CSPViolationReport = {
+    'document-uri': string;
+    'violated-directive': string;
+    'blocked-uri'?: string;
+    'source-file'?: string;
+    'line-number'?: number;
+    'column-number'?: number;
+    'script-sample'?: string;
+    'original-policy'?: string;
+    disposition?: 'enforce' | 'report';
+};
+
+/**
+ * τjs [ taujs ] Orchestration System
+ * (c) 2024-present Aoede Ltd
+ * Author: John Smith
+ *
+ * Licensed under the MIT License - attribution appreciated.
+ * Part of the τjs [ taujs ] system for declarative, build-time orchestration of microfrontend applications,
+ * including CSR, SSR, streaming, and middleware composition.
+ */
+
+type SecurityConfig = {
+    csp?: {
+        defaultMode?: 'merge' | 'replace';
+        directives?: CSPDirectives;
+        generateCSP?: (directives: CSPDirectives, nonce: string, req?: FastifyRequest) => string;
+        reporting?: {
+            endpoint: string;
+            onViolation?: (report: CSPViolationReport, req: FastifyRequest) => void;
+            reportOnly?: boolean;
+        };
+    };
+};
+type AppRoute = Omit<Route<PathToRegExpParams>, 'appId'> & {
+    attr?: RouteAttributes<PathToRegExpParams>;
+};
+type AppConfig = {
+    appId: string;
+    entryPoint: string;
+    plugins?: PluginOption[];
+    routes?: AppRoute[];
+};
+type TaujsConfig = {
+    server?: {
+        host?: string;
+        port?: number;
+        hmrPort?: number;
+    };
+    security?: SecurityConfig;
+    apps: AppConfig[];
+};
+
+declare function defineConfig<T extends TaujsConfig>(config: T): T;
+
+export { type AppConfig as A, type BaseLogger as B, type DebugConfig as D, type InitialRouteParams as I, type ServiceRegistry as S, type TaujsConfig as T, type SecurityConfig as a, type AppRoute as b, createLogger as c, defineConfig as d, defineServiceRegistry as e, defineService as f, type ServiceContext as g };

package/dist/Config.d.ts

@@ -1,3 +1,3 @@
 import 'fastify';
 import 'vite';
-export { A as AppConfig, q as AppRoute, p as SecurityConfig, T as TaujsConfig, r as defineConfig, t as defineService, s as defineServiceRegistry } from './Config-CjwAJCfZ.js';
+export { A as AppConfig, b as AppRoute, a as SecurityConfig, g as ServiceContext, T as TaujsConfig, d as defineConfig, f as defineService, e as defineServiceRegistry } from './Config-BuUuMjmO.js';

package/dist/Config.js

@@ -1,19 +1,26 @@
 // src/utils/DataServices.ts
-var defineService = (spec) => {
+import { performance } from "perf_hooks";
+var runSchema = (schema, input) => {
+  if (!schema) return input;
+  return typeof schema.parse === "function" ? schema.parse(input) : schema(input);
+};
+function defineService(spec) {
   const out = {};
-  for (const [k, v] of Object.entries(spec)) {
+  for (const [name, v] of Object.entries(spec)) {
     if (typeof v === "function") {
-      out[k] = { handler: v };
+      out[name] = v;
     } else {
-      out[k] = {
-        handler: v.handler,
-        parsers: v.parsers ?? (v.params || v.result ? { params: v.params, result: v.result } : void 0)
+      const { handler, params: paramsSchema, result: resultSchema } = v;
+      out[name] = async (params, ctx) => {
+        const p = runSchema(paramsSchema, params);
+        const r = await handler(p, ctx);
+        return runSchema(resultSchema, r);
       };
     }
   }
-  return out;
-};
-var defineServiceRegistry = (registry) => registry;
+  return Object.freeze(out);
+}
+var defineServiceRegistry = (registry) => Object.freeze(Object.fromEntries(Object.entries(registry).map(([k, v]) => [k, Object.freeze(v)])));
 
 // src/Config.ts
 function defineConfig(config) {

package/dist/index.d.ts

@@ -1,48 +1,13 @@
-import { S as SSRServerOptions, T as TaujsConfig, a as ServiceRegistry, D as DebugConfig, B as BaseLogger } from './Config-CjwAJCfZ.js';
-export { h as BaseMiddleware, C as Config, k as DataHandler, j as DataResult, G as GenericPlugin, I as InitialRouteParams, d as Manifest, M as ManifestEntry, l as PathToRegExpParams, P as ProcessedConfig, b as RenderCallbacks, g as RenderModule, e as RenderSSR, f as RenderStream, n as Route, m as RouteAttributes, R as RouteCSPConfig, o as RoutePathsAndAttributes, c as SSRManifest, i as ServiceCall } from './Config-CjwAJCfZ.js';
-import { FastifyPluginAsync, FastifyInstance, FastifyPluginCallback } from 'fastify';
+import { FastifyPluginCallback, FastifyPluginAsync, FastifyInstance } from 'fastify';
+import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, A as AppConfig } from './Config-BuUuMjmO.js';
+export { I as InitialRouteParams, c as createLogger } from './Config-BuUuMjmO.js';
 import 'vite';
 
-declare module 'fastify' {
-  interface FastifyRequest {
-    cspNonce?: string;
-  }
-
-  interface FastifyInstance {
-    /**
-     * Optional authentication hook to be used by the taujs SSRServer.
-     * This method must be decorated by the user when using auth middleware in `taujs.config.ts`.
-     *
-     * Example usage:
-     * ```ts
-     * fastify.decorate('authenticate', async function (req, reply) {
-     *   await req.jwtVerify();
-     * });
-     * ```
-     */
-    authenticate: (req: FastifyRequest, reply: FastifyReply) => Promise<void>;
-    showBanner(): void;
-    cspNonce?: string;
-  }
-}
-
-declare const TEMPLATE: {
-    readonly defaultEntryClient: "entry-client";
-    readonly defaultEntryServer: "entry-server";
-    readonly defaultHtmlTemplate: "index.html";
+type StaticMountEntry = {
+    plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
+    options?: Record<string, unknown>;
 };
-
-/**
- * τjs [ taujs ] Orchestration System
- * (c) 2024-present Aoede Ltd
- * Author: John Smith
- *
- * Licensed under the MIT License - attribution appreciated.
- * Part of the τjs [ taujs ] system for declarative, build-time orchestration of microfrontend applications,
- * including CSR, SSR, streaming, and middleware composition.
- */
-
-declare const SSRServer: FastifyPluginAsync<SSRServerOptions>;
+type StaticAssetsRegistration = false | StaticMountEntry | StaticMountEntry[];
 
 type NetResolved = {
     host: string;
@@ -50,10 +15,6 @@ type NetResolved = {
     hmrPort: number;
 };
 
-type StaticAssetsRegistration = {
-    plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
-    options?: Record<string, unknown>;
-};
 type CreateServerOptions = {
     config: TaujsConfig;
     serviceRegistry: ServiceRegistry;
@@ -62,7 +23,7 @@ type CreateServerOptions = {
     fastify?: FastifyInstance;
     debug?: DebugConfig;
     logger?: BaseLogger;
-    registerStaticAssets?: false | StaticAssetsRegistration;
+    staticAssets?: false | StaticAssetsRegistration;
     port?: number;
 };
 type CreateServerResult = {
@@ -71,4 +32,32 @@ type CreateServerResult = {
 };
 declare const createServer: (opts: CreateServerOptions) => Promise<CreateServerResult>;
 
-export { SSRServer, SSRServerOptions, TEMPLATE, createServer };
+/**
+ * τjs [ taujs ] Orchestration System
+ * (c) 2024-present Aoede Ltd
+ * Author: John Smith
+ *
+ * Licensed under the MIT License - attribution appreciated.
+ * Part of the τjs [ taujs ] system for declarative, build-time orchestration of microfrontend applications,
+ * including CSR, SSR, streaming, and middleware composition.
+ */
+
+declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, }: {
+    config: {
+        apps: AppConfig[];
+    };
+    projectRoot: string;
+    clientBaseDir: string;
+    isSSRBuild?: boolean;
+}): Promise<void>;
+
+interface MessageMetaLogger {
+    debug?: (message?: string, meta?: Record<string, unknown>) => unknown;
+    info?: (message?: string, meta?: Record<string, unknown>) => unknown;
+    warn?: (message?: string, meta?: Record<string, unknown>) => unknown;
+    error?: (message?: string, meta?: Record<string, unknown>) => unknown;
+    child?: (bindings: Record<string, unknown>) => MessageMetaLogger | undefined;
+}
+declare function winstonAdapter(winston: MessageMetaLogger): BaseLogger;
+
+export { createServer, taujsBuild, winstonAdapter };