@taujs/server 0.3.7 → 0.4.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-taujs [ τjs ] Orchestration System
+τjs [ taujs ] Orchestration System
 Author: John Smith
 Copyright (c) Aoede Ltd 2024-present
 

package/README.md

@@ -1,6 +1,8 @@
 # @taujs/server
 
-This package is part of the taujs [ τjs ] orchestration system, authored by John Smith | Aoede, 2024-present. Attribution is appreciated.
+https://www.taujs.dev
+
+This package is part of the τjs [ taujs ] orchestration system, authored by John Smith | Aoede, 2024-present. Attribution is appreciated.
 
 `npm install @taujs/server`
 
@@ -24,7 +26,7 @@ Supported application structure and composition:
 
 Assemble independent frontends at build time incorporating flexible per-route SPA-MPA hybrid with CSR, SSR, and Streaming SSR, rendering options.
 
-Fastify Plugin for integration with taujs [ τjs ] template https://github.com/aoede3/taujs
+Fastify Plugin for integration with τjs [ taujs ] template https://github.com/aoede3/taujs
 
 - Production: Fastify, React
 - Development: Fastify, React, tsx, Vite
@@ -55,7 +57,7 @@ Integrated Vite HMR run alongside tsx (TS eXecute) providing fast responsive dev
 
 https://github.com/aoede3/taujs/blob/main/src/server/index.ts
 
-Not utilising taujs [ τjs ] template? Add in your own ts `alias` object for your own particular directory setup e.g. `alias: { object }`
+Not utilising τjs [ taujs ] template? Add in your own ts `alias` object for your own particular directory setup e.g. `alias: { object }`
 
 ### React 'entry-client.tsx'
 

package/dist/Config-LCDjtT9m.d.ts

@@ -0,0 +1,175 @@
+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>>);
+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;
+}
+
+type Schema<T> = (input: unknown) => T;
+type LooseSpec = Readonly<Record<string, ServiceMethod<any, Record<string, unknown>> | {
+    handler: ServiceMethod<any, Record<string, unknown>>;
+    params?: Schema<any>;
+    result?: Schema<any>;
+    parsers?: {
+        params?: Schema<any>;
+        result?: Schema<any>;
+    };
+}>>;
+type ServiceContext = {
+    signal?: AbortSignal;
+    deadlineMs?: number;
+    traceId?: string;
+    logger?: Logs;
+    user?: {
+        id: string;
+        roles: string[];
+    } | null;
+};
+type ServiceMethod<P, R extends Record<string, unknown>> = (params: P, ctx: ServiceContext) => Promise<R>;
+type ServiceMethodDescriptor<P, R extends Record<string, unknown>> = {
+    handler: ServiceMethod<P, R>;
+    parsers?: {
+        params?: Schema<P>;
+        result?: Schema<R>;
+    };
+};
+type ServiceRegistry = Readonly<Record<string, Readonly<Record<string, ServiceMethodDescriptor<any, Record<string, unknown>>>>>>;
+declare const defineService: <T extends LooseSpec>(spec: T) => { [K in keyof T]: T[K] extends ServiceMethod<infer P, infer R> ? ServiceMethodDescriptor<P, R> : T[K] extends {
+    handler: ServiceMethod<infer P, infer R_1>;
+} ? ServiceMethodDescriptor<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;
+};
+type BaseMiddleware = {
+    auth?: {
+        redirect?: string;
+        roles?: string[];
+        strategy?: string;
+    };
+    csp?: RouteCSPConfig | false;
+};
+type ServiceCall = {
+    serviceName: string;
+    serviceMethod: string;
+    args?: Record<string, unknown>;
+};
+type DataResult = Record<string, unknown> | ServiceCall;
+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, defineServiceRegistry as c, defineConfig as d, defineService as e };

package/dist/Config.d.ts

@@ -0,0 +1,3 @@
+import 'fastify';
+import 'vite';
+export { A as AppConfig, b as AppRoute, a as SecurityConfig, T as TaujsConfig, d as defineConfig, e as defineService, c as defineServiceRegistry } from './Config-LCDjtT9m.js';

package/dist/Config.js

@@ -0,0 +1,27 @@
+// src/utils/DataServices.ts
+var defineService = (spec) => {
+  const out = {};
+  for (const [k, v] of Object.entries(spec)) {
+    if (typeof v === "function") {
+      out[k] = { handler: v };
+    } else {
+      out[k] = {
+        handler: v.handler,
+        parsers: v.parsers ?? (v.params || v.result ? { params: v.params, result: v.result } : void 0)
+      };
+    }
+  }
+  return out;
+};
+var defineServiceRegistry = (registry) => registry;
+
+// src/Config.ts
+function defineConfig(config) {
+  if (!config.apps || config.apps.length === 0) throw new Error("At least one app must be configured");
+  return config;
+}
+export {
+  defineConfig,
+  defineService,
+  defineServiceRegistry
+};

package/dist/index.d.ts

@@ -1,25 +1,54 @@
-import { FastifyReply } from 'fastify';
-export { B as BaseMiddleware, C as Config, n as DataHandler, D as DataResult, G as GenericPlugin, I as InitialRouteParams, i as Manifest, M as ManifestEntry, N as NamedService, P as ProcessedConfig, g as RenderCallbacks, l as RenderModule, j as RenderSSR, k as RenderStream, R as Route, b as RouteAttributes, a as RouteParams, o as RoutePathsAndAttributes, h as SSRManifest, S as SSRServer, d as SSRServerOptions, m as ServiceCall, e as ServiceMethod, f as ServiceRegistry, T as TEMPLATE, c as createMaps, p as processConfigs } from './SSRServer-CbXIDaoA.js';
-import 'node:http';
+import { FastifyPluginCallback, FastifyPluginAsync, FastifyInstance } from 'fastify';
+import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, A as AppConfig } from './Config-LCDjtT9m.js';
+export { I as InitialRouteParams } from './Config-LCDjtT9m.js';
 import 'vite';
-import './security/csp.js';
 
-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>;
-  }
-}
+type StaticMountEntry = {
+    plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
+    options?: Record<string, unknown>;
+};
+type StaticAssetsRegistration = false | StaticMountEntry | StaticMountEntry[];
+
+type NetResolved = {
+    host: string;
+    port: number;
+    hmrPort: number;
+};
+
+type CreateServerOptions = {
+    config: TaujsConfig;
+    serviceRegistry: ServiceRegistry;
+    clientRoot?: string;
+    alias?: Record<string, string>;
+    fastify?: FastifyInstance;
+    debug?: DebugConfig;
+    logger?: BaseLogger;
+    staticAssets?: false | StaticAssetsRegistration;
+    port?: number;
+};
+type CreateServerResult = {
+    app?: FastifyInstance;
+    net: NetResolved;
+};
+declare const createServer: (opts: CreateServerOptions) => Promise<CreateServerResult>;
+
+/**
+ * τ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>;
+
+export { createServer, taujsBuild };