@taujs/server 0.3.6 → 0.4.0

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/{build.d.ts → Build.d.ts}

@@ -1,16 +1,14 @@
-import { AppConfig } from './config.js';
-import 'vite';
-import './SSRServer-DPZped7n.js';
-import 'node:http';
+import { A as AppConfig } from './Config-CjwAJCfZ.js';
 import 'fastify';
+import 'vite';
 
 /**
- * taujs [ τjs ] Orchestration System
+ * τjs [ taujs ] Orchestration System
  * (c) 2024-present Aoede Ltd
  * Author: John Smith
  *
- * Licensed under the MIT License — attribution appreciated.
- * Part of the taujs [ τjs ] system for declarative, build-time orchestration of microfrontend applications,
+ * 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.
  */
 

package/dist/{config.js → Build.js}

@@ -97,50 +97,132 @@ var require_picocolors = __commonJS({
   }
 });
 
-// src/config.ts
+// src/Build.ts
+import path3 from "path";
+import { build } from "vite";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+
+// src/utils/AssetManager.ts
+import path2 from "path";
+
+// src/utils/System.ts
+import { dirname, join } from "path";
+import "path";
+import { fileURLToPath } from "url";
+var isDevelopment = process.env.NODE_ENV === "development";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = join(dirname(__filename), !isDevelopment ? "./" : "..");
+
+// src/constants.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
-import { performance } from "perf_hooks";
-var extractBuildConfigs = (config) => {
-  return config.apps.map(({ appId, entryPoint, plugins }) => ({
-    appId,
-    entryPoint,
-    plugins
-  }));
+var TEMPLATE = {
+  defaultEntryClient: "entry-client",
+  defaultEntryServer: "entry-server",
+  defaultHtmlTemplate: "index.html"
 };
-var extractRoutes = (taujsConfig) => {
-  console.log(import_picocolors.default.bold("Preparing taujs [ \u03C4js ]"));
-  const t0 = performance.now();
-  try {
-    const allRoutes = [];
-    const pathTracker = /* @__PURE__ */ new Map();
-    let totalRoutes = 0;
-    for (const app of taujsConfig.apps) {
-      const appRoutes = (app.routes ?? []).map((route) => {
-        const fullRoute = { ...route, appId: app.appId };
-        if (!pathTracker.has(route.path)) pathTracker.set(route.path, []);
-        pathTracker.get(route.path).push(app.appId);
-        return fullRoute;
-      });
-      console.log(import_picocolors.default.gray(` \u2022 ${app.appId}: ${appRoutes.length} route(s)`));
-      allRoutes.push(...appRoutes);
-      totalRoutes += appRoutes.length;
+var DEBUG = {
+  auth: { label: "auth", colour: import_picocolors.default.blue },
+  csp: { label: "csp", colour: import_picocolors.default.yellow },
+  errors: { label: "errors", colour: import_picocolors.default.red },
+  routes: { label: "routes", colour: import_picocolors.default.cyan },
+  security: { label: "security", colour: import_picocolors.default.yellow },
+  trx: { label: "trx", colour: import_picocolors.default.magenta },
+  vite: { label: "vite", colour: import_picocolors.default.yellow }
+};
+
+// src/utils/AssetManager.ts
+var processConfigs = (configs, baseClientRoot, templateDefaults) => {
+  return configs.map((config) => {
+    const clientRoot = path2.resolve(baseClientRoot, config.entryPoint);
+    return {
+      clientRoot,
+      entryPoint: config.entryPoint,
+      entryClient: config.entryClient || templateDefaults.defaultEntryClient,
+      entryServer: config.entryServer || templateDefaults.defaultEntryServer,
+      htmlTemplate: config.htmlTemplate || templateDefaults.defaultHtmlTemplate,
+      appId: config.appId
+    };
+  });
+};
+
+// src/Build.ts
+async function taujsBuild({
+  configs,
+  projectRoot,
+  clientBaseDir,
+  isSSRBuild = process.env.BUILD_MODE === "ssr"
+}) {
+  const deleteDist = async () => {
+    const { rm } = await import("fs/promises");
+    const distPath = path3.resolve(projectRoot, "dist");
+    try {
+      await rm(distPath, { recursive: true, force: true });
+      console.log("Deleted the dist directory\n");
+    } catch (err) {
+      console.error("Error deleting dist directory:", err);
     }
-    for (const [path, appIds] of pathTracker.entries()) {
-      if (appIds.length > 1) console.warn(import_picocolors.default.yellow(`\u26A0\uFE0F Route path "${path}" is declared in multiple apps: ${appIds.join(", ")} \u2013 order may affect matching`));
+  };
+  const processedConfigs = processConfigs(configs, clientBaseDir, TEMPLATE);
+  if (!isSSRBuild) await deleteDist();
+  for (const config of processedConfigs) {
+    const { appId, entryPoint, clientRoot, entryClient, entryServer, htmlTemplate, plugins = [] } = config;
+    const outDir = path3.resolve(projectRoot, `dist/client/${entryPoint}`);
+    const root = entryPoint ? path3.resolve(clientBaseDir, entryPoint) : clientBaseDir;
+    const server = path3.resolve(clientRoot, `${entryServer}.tsx`);
+    const client = path3.resolve(clientRoot, `${entryClient}.tsx`);
+    const main = path3.resolve(clientRoot, htmlTemplate);
+    const viteConfig = {
+      base: entryPoint ? `/${entryPoint}/` : "/",
+      build: {
+        outDir,
+        manifest: !isSSRBuild,
+        rollupOptions: {
+          input: isSSRBuild ? { server } : { client, main }
+        },
+        ssr: isSSRBuild ? server : void 0,
+        ssrManifest: isSSRBuild,
+        ...isSSRBuild && {
+          format: "esm",
+          target: `node${process.versions.node.split(".").map(Number)[0]}`
+        }
+      },
+      css: {
+        preprocessorOptions: {
+          scss: { api: "modern-compiler" }
+        }
+      },
+      plugins: [...config.plugins ?? [], nodePolyfills({ include: ["fs", "stream"] })],
+      publicDir: "public",
+      resolve: {
+        alias: {
+          "@client": root,
+          "@server": path3.resolve(projectRoot, "src/server"),
+          "@shared": path3.resolve(projectRoot, "src/shared")
+        }
+      },
+      root,
+      server: {
+        proxy: {
+          "/api": {
+            target: "http://localhost:3000",
+            changeOrigin: true,
+            rewrite: (path4) => path4.replace(/^\/api/, "")
+          }
+        }
+      }
+    };
+    try {
+      console.log(`Building for entryPoint: "${entryPoint}" (${appId})`);
+      await build(viteConfig);
+      console.log(`Build complete for entryPoint: "${entryPoint}"
+`);
+    } catch (error) {
+      console.error(`Error building for entryPoint: "${entryPoint}"
+`, error);
+      process.exit(1);
     }
-    const sortedRoutes = allRoutes.sort((a, b) => computeScore(b.path) - computeScore(a.path));
-    const t1 = performance.now();
-    console.log(import_picocolors.default.green(`Prepared ${totalRoutes} route(s) in ${(t1 - t0).toFixed(1)}ms`));
-    return sortedRoutes;
-  } catch (err) {
-    console.log(import_picocolors.default.red("Failed to prepare routes"));
-    throw err;
   }
-};
-var computeScore = (path) => {
-  return path.split("/").filter(Boolean).reduce((score, segment) => score + (segment.startsWith(":") ? 1 : 10), 0);
-};
+}
 export {
-  extractBuildConfigs,
-  extractRoutes
+  taujsBuild
 };

package/dist/Config-CjwAJCfZ.d.ts

@@ -0,0 +1,245 @@
+import { FastifyRequest, FastifyPluginCallback, FastifyPluginAsync } 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?(message: string, meta?: unknown): void;
+    info?(message: string, meta?: unknown): void;
+    warn?(message: string, meta?: unknown): void;
+    error?(message: string, meta?: unknown): void;
+    log?(message: string, meta?: unknown): void;
+}
+interface Logs extends BaseLogger {
+    debug(message: string, meta?: unknown): void;
+    debug(category: DebugCategory, message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): 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 Config = {
+    appId: string;
+    entryPoint: string;
+    entryClient?: string;
+    entryServer?: string;
+    htmlTemplate?: string;
+};
+type ProcessedConfig = {
+    appId: string;
+    clientRoot: string;
+    entryClient: string;
+    entryPoint: string;
+    entryServer: string;
+    htmlTemplate: string;
+    plugins?: PluginOption[];
+};
+type SSRServerOptions = {
+    alias?: Record<string, string>;
+    clientRoot: string;
+    configs: AppConfig[];
+    routes: Route<PathToRegExpParams>[];
+    serviceRegistry: ServiceRegistry;
+    security?: SecurityConfig;
+    registerStaticAssets?: false | {
+        plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
+        options?: Record<string, unknown>;
+    };
+    debug?: DebugConfig;
+    devNet?: {
+        host: string;
+        hmrPort: number;
+    };
+};
+type RenderCallbacks<T = unknown> = {
+    onHead?: (headContent: string) => void;
+    onShellReady?: () => void;
+    onAllReady?: (initialData: T) => void;
+    onError?: (error: unknown) => void;
+};
+type SSRManifest = {
+    [key: string]: string[];
+};
+type ManifestEntry = {
+    file: string;
+    src?: string;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+    assets?: string[];
+};
+type Manifest = {
+    [key: string]: ManifestEntry;
+};
+type RenderSSR = (initialDataResolved: Record<string, unknown>, location: string, meta?: Record<string, unknown>, signal?: AbortSignal, opts?: {
+    logger?: Logs;
+}) => Promise<{
+    headContent: string;
+    appHtml: string;
+}>;
+type RenderStream = (serverResponse: NodeJS.WritableStream, callbacks: RenderCallbacks, initialData: Record<string, unknown> | Promise<Record<string, unknown>> | (() => Promise<Record<string, unknown>>), location: string, bootstrapModules?: string, meta?: Record<string, unknown>, cspNonce?: string, signal?: AbortSignal, opts?: {
+    logger?: Logs;
+}) => {
+    abort(): void;
+};
+type RenderModule = {
+    renderSSR: RenderSSR;
+    renderStream: RenderStream;
+};
+type GenericPlugin = FastifyPluginCallback<Record<string, unknown>> | FastifyPluginAsync<Record<string, unknown>>;
+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 RoutePathsAndAttributes<Params extends PathToRegExpParams = PathToRegExpParams> = Omit<Route<Params>, 'element'>;
+
+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 Config as C, type DebugConfig as D, type GenericPlugin as G, type InitialRouteParams as I, type ManifestEntry as M, type ProcessedConfig as P, type RouteCSPConfig as R, type SSRServerOptions as S, type TaujsConfig as T, type ServiceRegistry as a, type RenderCallbacks as b, type SSRManifest as c, type Manifest as d, type RenderSSR as e, type RenderStream as f, type RenderModule as g, type BaseMiddleware as h, type ServiceCall as i, type DataResult as j, type DataHandler as k, type PathToRegExpParams as l, type RouteAttributes as m, type Route as n, type RoutePathsAndAttributes as o, type SecurityConfig as p, type AppRoute as q, defineConfig as r, defineServiceRegistry as s, defineService as t };

package/dist/Config.d.ts

@@ -0,0 +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';

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,12 +1,13 @@
-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-DPZped7n.js';
-import 'node:http';
+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 'vite';
 
 declare module 'fastify' {
   interface FastifyRequest {
-    nonce?: string;
+    cspNonce?: string;
   }
+
   interface FastifyInstance {
     /**
      * Optional authentication hook to be used by the taujs SSRServer.
@@ -20,5 +21,54 @@ declare module 'fastify' {
      * ```
      */
     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";
+};
+
+/**
+ * τ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 NetResolved = {
+    host: string;
+    port: number;
+    hmrPort: number;
+};
+
+type StaticAssetsRegistration = {
+    plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
+    options?: Record<string, unknown>;
+};
+type CreateServerOptions = {
+    config: TaujsConfig;
+    serviceRegistry: ServiceRegistry;
+    clientRoot?: string;
+    alias?: Record<string, string>;
+    fastify?: FastifyInstance;
+    debug?: DebugConfig;
+    logger?: BaseLogger;
+    registerStaticAssets?: false | StaticAssetsRegistration;
+    port?: number;
+};
+type CreateServerResult = {
+    app?: FastifyInstance;
+    net: NetResolved;
+};
+declare const createServer: (opts: CreateServerOptions) => Promise<CreateServerResult>;
+
+export { SSRServer, SSRServerOptions, TEMPLATE, createServer };