@taujs/server 0.5.3 → 0.5.4

package/dist/{Config-DHz6Lax2.d.ts → Config-2Loymxo2.d.ts}

@@ -7,10 +7,10 @@ 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;
+    debug?(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>): BaseLogger;
 }
 interface Logs extends BaseLogger {
@@ -67,19 +67,20 @@ declare function callServiceMethod(registry: ServiceRegistry, serviceName: strin
 type RequestContext<L extends Logs = Logs> = {
     traceId: string;
     logger: L;
-    headers: Record<string, string>;
+    headers?: Record<string, string>;
 };
 
+type PathToRegExpParams = Partial<Record<string, string | string[]>>;
 type RouteCSPConfig = {
     disabled?: boolean;
     mode?: 'merge' | 'replace';
-    directives?: CSPDirectives | ((args: {
+    directives?: unknown | ((args: {
         url: string;
         params: PathToRegExpParams;
-        headers: FastifyRequest['headers'];
-        req: FastifyRequest;
-    }) => CSPDirectives);
-    generateCSP?: (directives: CSPDirectives, nonce: string, req: FastifyRequest) => string;
+        headers: Record<string, string>;
+        req?: unknown;
+    }) => unknown);
+    generateCSP?: (directives: unknown, nonce: string, req?: unknown) => string;
     reportOnly?: boolean;
 };
 type BaseMiddleware = {
@@ -91,14 +92,15 @@ type BaseMiddleware = {
     csp?: RouteCSPConfig | false;
 };
 type DataResult = Record<string, unknown> | ServiceDescriptor;
-type RequestServiceContext<L extends Logs = Logs> = RequestContext<L> & {
-    call: RegistryCaller<ServiceRegistry>;
-    headers?: Record<string, string>;
+type RequestServiceContext<L extends Logs = Logs> = ServiceContext & RequestContext<L> & {
+    call?: RegistryCaller<ServiceRegistry>;
+    headers: Record<string, string>;
 };
-type DataHandler<Params extends PathToRegExpParams, L extends Logs = Logs> = (params: Params, ctx: RequestServiceContext<L> & {
+type DataHandler<Params extends PathToRegExpParams, L extends Logs = Logs> = (params: Params, ctx: (RequestServiceContext<L> & {
+    call: RegistryCaller<ServiceRegistry>;
+}) & {
     [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;
@@ -117,10 +119,6 @@ type Route<Params extends PathToRegExpParams = PathToRegExpParams> = {
     path: string;
     appId?: string;
 };
-interface InitialRouteParams extends Record<string, unknown> {
-    serviceName?: string;
-    serviceMethod?: string;
-}
 type AppId<C extends {
     apps: readonly {
         appId: string;
@@ -152,16 +150,46 @@ type SingleRouteContext<C extends {
         attr?: infer Attr;
     } ? Attr : never;
 } : never;
-type RouteContext<C extends {
+type RouteContext$1<C extends {
     apps: readonly any[];
 }> = {
     [A in AppId<C>]: SingleRouteContext<C, A, RoutesOfApp<C, A>>;
 }[AppId<C>];
-type RouteData<C extends {
+type RouteData$1<C extends {
     apps: readonly any[];
-}, Path extends string> = Extract<RouteContext<C>, {
+}, Path extends string> = Extract<RouteContext$1<C>, {
     path: Path;
 }>['data'];
+type CoreSecurityConfig = {
+    csp?: {
+        defaultMode?: 'merge' | 'replace';
+        directives?: unknown;
+        generateCSP?: (directives: unknown, nonce: string, req?: unknown) => string;
+        reporting?: {
+            endpoint: string;
+            onViolation?: (report: unknown, req: unknown) => void;
+            reportOnly?: boolean;
+        };
+    };
+};
+type AppRoute = Omit<Route<PathToRegExpParams>, 'appId'> & {
+    attr?: RouteAttributes<PathToRegExpParams>;
+};
+type CoreAppConfig = {
+    appId: string;
+    entryPoint: string;
+    plugins?: readonly unknown[];
+    routes?: readonly AppRoute[];
+};
+type CoreTaujsConfig = {
+    apps: readonly CoreAppConfig[];
+    security?: CoreSecurityConfig;
+    server?: {
+        host?: string;
+        port?: number;
+        hmrPort?: number;
+    };
+};
 
 type CSPDirectives = Record<string, string[]>;
 
@@ -206,17 +234,7 @@ declare class AppError extends Error {
     static from(err: unknown, fallback?: string): AppError;
 }
 
-/**
- * τ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 = {
+type SecurityConfig = CoreSecurityConfig & {
     csp?: {
         defaultMode?: 'merge' | 'replace';
         directives?: CSPDirectives;
@@ -228,25 +246,18 @@ type SecurityConfig = {
         };
     };
 };
-type AppRoute = Omit<Route<PathToRegExpParams>, 'appId'> & {
-    attr?: RouteAttributes<PathToRegExpParams>;
-};
-type AppConfig = {
-    appId: string;
-    entryPoint: string;
+type AppConfig = CoreAppConfig & {
     plugins?: PluginOption[];
     routes?: readonly AppRoute[];
 };
-type TaujsConfig = {
+type TaujsConfig = CoreTaujsConfig & {
     apps: readonly AppConfig[];
     security?: SecurityConfig;
-    server?: {
-        host?: string;
-        port?: number;
-        hmrPort?: number;
-    };
 };
 
-declare function defineConfig<const C>(config: C & TaujsConfig): C;
+type RouteContext = RouteContext$1<TaujsConfig>;
+type RouteData<C extends TaujsConfig = TaujsConfig, P extends string = string> = RouteData$1<C, P>;
+
+declare function defineConfig<const C extends TaujsConfig>(config: C): C;
 
-export { type AppConfig as A, type BaseLogger as B, type DebugConfig as D, type InitialRouteParams as I, type RegistryCaller as R, type ServiceRegistry as S, type TaujsConfig as T, type SecurityConfig as a, type AppRoute as b, callServiceMethod as c, defineConfig as d, defineService as e, defineServiceRegistry as f, type ServiceContext as g, type RouteContext as h, type RouteData as i, AppError as j, withDeadline as w };
+export { type AppConfig as A, type BaseLogger as B, type CoreAppConfig as C, type DebugConfig as D, type RouteContext as R, type ServiceRegistry as S, type TaujsConfig as T, type SecurityConfig as a, type RouteData as b, callServiceMethod as c, defineConfig as d, defineService as e, defineServiceRegistry as f, type RegistryCaller as g, type ServiceContext as h, AppError as i, withDeadline as w };

package/dist/Config.d.ts

@@ -1,3 +1,3 @@
 import 'fastify';
 import 'vite';
-export { A as AppConfig, j as AppError, b as AppRoute, R as RegistryCaller, h as RouteContext, i as RouteData, a as SecurityConfig, g as ServiceContext, T as TaujsConfig, c as callServiceMethod, d as defineConfig, e as defineService, f as defineServiceRegistry, w as withDeadline } from './Config-DHz6Lax2.js';
+export { A as AppConfig, i as AppError, g as RegistryCaller, R as RouteContext, b as RouteData, a as SecurityConfig, h as ServiceContext, T as TaujsConfig, c as callServiceMethod, d as defineConfig, e as defineService, f as defineServiceRegistry, w as withDeadline } from './Config-2Loymxo2.js';

package/dist/Config.js

@@ -1,7 +1,4 @@
-// src/utils/DataServices.ts
-import { performance } from "perf_hooks";
-
-// src/logging/AppError.ts
+// src/core/errors/AppError.ts
 var HTTP_STATUS = {
   infra: 500,
   upstream: 502,
@@ -111,7 +108,27 @@ var AppError = class _AppError extends Error {
   }
 };
 
-// src/utils/DataServices.ts
+// src/core/logging/noop.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  child: () => noopLogger,
+  isDebugEnabled: () => false
+};
+
+// src/core/logging/resolve.ts
+var resolveLogs = (logger) => logger ?? noopLogger;
+
+// src/core/telemetry/Telemetry.ts
+var now = () => globalThis.performance?.now?.() ?? Date.now();
+
+// src/core/services/DataServices.ts
 var runSchema = (schema, input) => {
   if (!schema) return input;
   return typeof schema.parse === "function" ? schema.parse(input) : schema(input);
@@ -155,26 +172,27 @@ async function callServiceMethod(registry, serviceName, methodName, params, ctx)
   if (!service) throw AppError.notFound(`Unknown service: ${serviceName}`);
   const method = service[methodName];
   if (!method) throw AppError.notFound(`Unknown method: ${serviceName}.${methodName}`);
-  const logger = ctx.logger?.child?.({
+  const baseLogger = resolveLogs(ctx.logger);
+  const logger = baseLogger.child({
     component: "service-call",
     service: serviceName,
     method: methodName,
     traceId: ctx.traceId
   });
-  const t0 = performance.now();
+  const t0 = now();
   try {
     const result = await method(params ?? {}, ctx);
     if (typeof result !== "object" || result === null) {
       throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
     }
-    logger?.debug?.({ ms: +(performance.now() - t0).toFixed(1) }, "Service method ok");
+    logger.debug({ ms: +(now() - t0).toFixed(1) }, "Service method ok");
     return result;
   } catch (err) {
-    logger?.error?.(
+    logger.error(
       {
         params,
         error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
-        ms: +(performance.now() - t0).toFixed(1)
+        ms: +(now() - t0).toFixed(1)
       },
       "Service method failed"
     );

package/dist/index.d.ts

@@ -1,20 +1,19 @@
 import { FastifyPluginCallback, FastifyPluginAsync, FastifyInstance } from 'fastify';
-import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, A as AppConfig } from './Config-DHz6Lax2.js';
-export { I as InitialRouteParams } from './Config-DHz6Lax2.js';
+import { T as TaujsConfig, S as ServiceRegistry, D as DebugConfig, B as BaseLogger, C as CoreAppConfig } from './Config-2Loymxo2.js';
 import { InlineConfig } from 'vite';
 
-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 StaticMountEntry = {
+    plugin: FastifyPluginCallback<any> | FastifyPluginAsync<any>;
+    options?: Record<string, unknown>;
+};
+type StaticAssetsRegistration = false | StaticMountEntry | StaticMountEntry[];
+
 type CreateServerOptions = {
     config: TaujsConfig;
     serviceRegistry?: ServiceRegistry;
@@ -95,7 +94,7 @@ type ViteBuildContext = {
 type ViteConfigOverride = Partial<InlineConfig> | ((ctx: ViteBuildContext) => Partial<InlineConfig>);
 declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, alias: userAlias, vite: userViteConfig, }: {
     config: {
-        apps: readonly AppConfig[];
+        apps: readonly CoreAppConfig[];
     };
     projectRoot: string;
     clientBaseDir: string;
@@ -131,4 +130,9 @@ interface MessageMetaLogger {
 }
 declare function winstonAdapter(winston: MessageMetaLogger): BaseLogger;
 
-export { BaseLogger, createServer, taujsBuild, winstonAdapter };
+interface InitialRouteParams extends Record<string, unknown> {
+    serviceName?: string;
+    serviceMethod?: string;
+}
+
+export { BaseLogger, type InitialRouteParams, createServer, taujsBuild, winstonAdapter };