@taujs/server 0.4.1 → 0.4.2

package/dist/{Config-LCDjtT9m.d.ts → Config-BuUuMjmO.d.ts}

@@ -6,6 +6,7 @@ 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;
@@ -22,17 +23,51 @@ interface Logs extends BaseLogger {
     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 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 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;
@@ -43,18 +78,21 @@ type ServiceContext = {
         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 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;
 };
-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 {
+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>;
-} ? ServiceMethodDescriptor<P, R_1> : never; };
+} ? ServiceMethod<P, R_1> : never; };
 declare const defineServiceRegistry: <R extends ServiceRegistry>(registry: R) => R;
 
 type RequestContext<L extends Logs = Logs> = {
@@ -73,6 +111,7 @@ type RouteCSPConfig = {
         req: FastifyRequest;
     }) => CSPDirectives);
     generateCSP?: (directives: CSPDirectives, nonce: string, req: FastifyRequest) => string;
+    reportOnly?: boolean;
 };
 type BaseMiddleware = {
     auth?: {
@@ -82,12 +121,7 @@ type BaseMiddleware = {
     };
     csp?: RouteCSPConfig | false;
 };
-type ServiceCall = {
-    serviceName: string;
-    serviceMethod: string;
-    args?: Record<string, unknown>;
-};
-type DataResult = Record<string, unknown> | ServiceCall;
+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>;
@@ -172,4 +206,4 @@ type TaujsConfig = {
 
 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 };
+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, b as AppRoute, a as SecurityConfig, T as TaujsConfig, d as defineConfig, e as defineService, c as defineServiceRegistry } from './Config-LCDjtT9m.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,6 +1,6 @@
 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 { 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';
 
 type StaticMountEntry = {
@@ -51,4 +51,13 @@ declare function taujsBuild({ config, projectRoot, clientBaseDir, isSSRBuild, }:
     isSSRBuild?: boolean;
 }): Promise<void>;
 
-export { createServer, taujsBuild };
+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 };

package/dist/index.js

@@ -190,7 +190,7 @@ var require_plugin = __commonJS({
 // src/CreateServer.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 import path5 from "path";
-import { performance as performance2 } from "perf_hooks";
+import { performance as performance3 } from "perf_hooks";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 
@@ -348,9 +348,129 @@ var computeScore = (path7) => {
   return path7.split("/").filter(Boolean).reduce((score, segment) => score + (segment.startsWith(":") ? 1 : 10), 0);
 };
 
-// src/network/Network.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-import { networkInterfaces } from "os";
+// src/logging/AppError.ts
+var HTTP_STATUS = {
+  infra: 500,
+  upstream: 502,
+  domain: 404,
+  validation: 400,
+  auth: 403,
+  canceled: 499,
+  // Client Closed Request (nginx convention)
+  timeout: 504
+};
+var AppError = class _AppError extends Error {
+  kind;
+  httpStatus;
+  details;
+  safeMessage;
+  code;
+  constructor(message, kind, options = {}) {
+    super(message);
+    this.name = "AppError";
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: false,
+        configurable: true
+      });
+    }
+    this.kind = kind;
+    this.httpStatus = options.httpStatus ?? HTTP_STATUS[kind];
+    this.details = options.details;
+    this.safeMessage = options.safeMessage ?? this.getSafeMessage(kind, message);
+    this.code = options.code;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+  }
+  getSafeMessage(kind, message) {
+    return kind === "domain" || kind === "validation" || kind === "auth" ? message : "Internal Server Error";
+  }
+  serialiseValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+    if (value === null || value === void 0) return value;
+    if (typeof value !== "object") return value;
+    if (seen.has(value)) return "[circular]";
+    seen.add(value);
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        ...value instanceof _AppError && {
+          kind: value.kind,
+          httpStatus: value.httpStatus,
+          code: value.code
+        }
+      };
+    }
+    if (Array.isArray(value)) return value.map((item) => this.serialiseValue(item, seen));
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = this.serialiseValue(val, seen);
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      kind: this.kind,
+      message: this.message,
+      safeMessage: this.safeMessage,
+      httpStatus: this.httpStatus,
+      ...this.code && { code: this.code },
+      details: this.serialiseValue(this.details),
+      stack: this.stack,
+      ...this.cause && {
+        cause: this.serialiseValue(this.cause)
+      }
+    };
+  }
+  static notFound(message, details, code) {
+    return new _AppError(message, "domain", { httpStatus: 404, details, code });
+  }
+  static forbidden(message, details, code) {
+    return new _AppError(message, "auth", { httpStatus: 403, details, code });
+  }
+  static badRequest(message, details, code) {
+    return new _AppError(message, "validation", { httpStatus: 400, details, code });
+  }
+  static unprocessable(message, details, code) {
+    return new _AppError(message, "validation", { httpStatus: 422, details, code });
+  }
+  static timeout(message, details, code) {
+    return new _AppError(message, "timeout", { details, code });
+  }
+  static canceled(message, details, code) {
+    return new _AppError(message, "canceled", { details, code });
+  }
+  static internal(message, cause, details, code) {
+    return new _AppError(message, "infra", { cause, details, code });
+  }
+  static upstream(message, cause, details, code) {
+    return new _AppError(message, "upstream", { cause, details, code });
+  }
+  static serviceUnavailable(message, cause, details, code) {
+    return new _AppError(message, "infra", { httpStatus: 503, cause, details, code });
+  }
+  static from(err, fallback = "Internal error") {
+    return err instanceof _AppError ? err : _AppError.internal(err?.message ?? fallback, err);
+  }
+};
+function normaliseError(e) {
+  if (e instanceof Error) return { name: e.name, message: e.message, stack: e.stack };
+  const hasMessageProp = e != null && typeof e.message !== "undefined";
+  const msg = hasMessageProp ? String(e.message) : String(e);
+  return { name: "Error", message: msg };
+}
+function toReason(e) {
+  if (e instanceof Error) return e;
+  if (e === null) return new Error("null");
+  if (typeof e === "undefined") return new Error("Unknown render error");
+  const maybeMsg = e?.message;
+  if (typeof maybeMsg !== "undefined") return new Error(String(maybeMsg));
+  return new Error(String(e));
+}
 
 // src/logging/Logger.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
@@ -554,7 +674,54 @@ function createLogger(opts) {
   return logger;
 }
 
+// src/network/CLI.ts
+function readFlag(argv, keys, bareValue) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  for (let i = 0; i < limit; i++) {
+    const arg = argv[i];
+    for (const key of keys) {
+      if (arg === key) {
+        const next = argv[i + 1];
+        if (!next || next.startsWith("-")) return bareValue;
+        return next.trim();
+      }
+      const pref = `${key}=`;
+      if (arg && arg.startsWith(pref)) {
+        const v = arg.slice(pref.length).trim();
+        return v || bareValue;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveNet(input) {
+  const env = process.env;
+  const argv = process.argv;
+  let host = "localhost";
+  let port = 5173;
+  let hmrPort = 5174;
+  if (input?.host) host = input.host;
+  if (Number.isFinite(input?.port)) port = Number(input.port);
+  if (Number.isFinite(input?.hmrPort)) hmrPort = Number(input.hmrPort);
+  if (env.HOST?.trim()) host = env.HOST.trim();
+  else if (env.FASTIFY_ADDRESS?.trim()) host = env.FASTIFY_ADDRESS.trim();
+  if (env.PORT) port = Number(env.PORT) || port;
+  if (env.FASTIFY_PORT) port = Number(env.FASTIFY_PORT) || port;
+  if (env.HMR_PORT) hmrPort = Number(env.HMR_PORT) || hmrPort;
+  const cliHost = readFlag(argv, ["--host", "--hostname", "-H"], "0.0.0.0");
+  const cliPort = readFlag(argv, ["--port", "-p"]);
+  const cliHMR = readFlag(argv, ["--hmr-port"]);
+  if (cliHost) host = cliHost;
+  if (cliPort) port = Number(cliPort) || port;
+  if (cliHMR) hmrPort = Number(cliHMR) || hmrPort;
+  if (host === "true" || host === "") host = "0.0.0.0";
+  return { host, port, hmrPort };
+}
+
 // src/network/Network.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { networkInterfaces } from "os";
 var isPrivateIPv4 = (addr) => {
   if (!/^\d+\.\d+\.\d+\.\d+$/.test(addr)) return false;
   const [a, b, _c, _d] = addr.split(".").map(Number);
@@ -606,51 +773,6 @@ var bannerPlugin = async (fastify, options) => {
   });
 };
 
-// src/network/CLI.ts
-function readFlag(argv, keys, bareValue) {
-  const end = argv.indexOf("--");
-  const limit = end === -1 ? argv.length : end;
-  for (let i = 0; i < limit; i++) {
-    const arg = argv[i];
-    for (const key of keys) {
-      if (arg === key) {
-        const next = argv[i + 1];
-        if (!next || next.startsWith("-")) return bareValue;
-        return next.trim();
-      }
-      const pref = `${key}=`;
-      if (arg && arg.startsWith(pref)) {
-        const v = arg.slice(pref.length).trim();
-        return v || bareValue;
-      }
-    }
-  }
-  return void 0;
-}
-function resolveNet(input) {
-  const env = process.env;
-  const argv = process.argv;
-  let host = "localhost";
-  let port = 5173;
-  let hmrPort = 5174;
-  if (input?.host) host = input.host;
-  if (Number.isFinite(input?.port)) port = Number(input.port);
-  if (Number.isFinite(input?.hmrPort)) hmrPort = Number(input.hmrPort);
-  if (env.HOST?.trim()) host = env.HOST.trim();
-  else if (env.FASTIFY_ADDRESS?.trim()) host = env.FASTIFY_ADDRESS.trim();
-  if (env.PORT) port = Number(env.PORT) || port;
-  if (env.FASTIFY_PORT) port = Number(env.FASTIFY_PORT) || port;
-  if (env.HMR_PORT) hmrPort = Number(env.HMR_PORT) || hmrPort;
-  const cliHost = readFlag(argv, ["--host", "--hostname", "-H"], "0.0.0.0");
-  const cliPort = readFlag(argv, ["--port", "-p"]);
-  const cliHMR = readFlag(argv, ["--hmr-port"]);
-  if (cliHost) host = cliHost;
-  if (cliPort) port = Number(cliPort) || port;
-  if (cliHMR) hmrPort = Number(cliHMR) || hmrPort;
-  if (host === "true" || host === "") host = "0.0.0.0";
-  return { host, port, hmrPort };
-}
-
 // src/security/VerifyMiddleware.ts
 var isAuthRequired = (route) => Boolean(route.attr?.middleware?.auth);
 var hasAuthenticate = (app) => typeof app.authenticate === "function";
@@ -718,130 +840,6 @@ var verifyContracts = (app, routes, contracts, security) => {
 // src/SSRServer.ts
 var import_fastify_plugin3 = __toESM(require_plugin(), 1);
 
-// src/logging/AppError.ts
-var HTTP_STATUS = {
-  infra: 500,
-  upstream: 502,
-  domain: 404,
-  validation: 400,
-  auth: 403,
-  canceled: 499,
-  // Client Closed Request (nginx convention)
-  timeout: 504
-};
-var AppError = class _AppError extends Error {
-  kind;
-  httpStatus;
-  details;
-  safeMessage;
-  code;
-  constructor(message, kind, options = {}) {
-    super(message);
-    this.name = "AppError";
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (options.cause !== void 0) {
-      Object.defineProperty(this, "cause", {
-        value: options.cause,
-        enumerable: false,
-        writable: false,
-        configurable: true
-      });
-    }
-    this.kind = kind;
-    this.httpStatus = options.httpStatus ?? HTTP_STATUS[kind];
-    this.details = options.details;
-    this.safeMessage = options.safeMessage ?? this.getSafeMessage(kind, message);
-    this.code = options.code;
-    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-  }
-  getSafeMessage(kind, message) {
-    return kind === "domain" || kind === "validation" || kind === "auth" ? message : "Internal Server Error";
-  }
-  serialiseValue(value, seen = /* @__PURE__ */ new WeakSet()) {
-    if (value === null || value === void 0) return value;
-    if (typeof value !== "object") return value;
-    if (seen.has(value)) return "[circular]";
-    seen.add(value);
-    if (value instanceof Error) {
-      return {
-        name: value.name,
-        message: value.message,
-        stack: value.stack,
-        ...value instanceof _AppError && {
-          kind: value.kind,
-          httpStatus: value.httpStatus,
-          code: value.code
-        }
-      };
-    }
-    if (Array.isArray(value)) return value.map((item) => this.serialiseValue(item, seen));
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = this.serialiseValue(val, seen);
-    }
-    return result;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      kind: this.kind,
-      message: this.message,
-      safeMessage: this.safeMessage,
-      httpStatus: this.httpStatus,
-      ...this.code && { code: this.code },
-      details: this.serialiseValue(this.details),
-      stack: this.stack,
-      ...this.cause && {
-        cause: this.serialiseValue(this.cause)
-      }
-    };
-  }
-  static notFound(message, details, code) {
-    return new _AppError(message, "domain", { httpStatus: 404, details, code });
-  }
-  static forbidden(message, details, code) {
-    return new _AppError(message, "auth", { httpStatus: 403, details, code });
-  }
-  static badRequest(message, details, code) {
-    return new _AppError(message, "validation", { httpStatus: 400, details, code });
-  }
-  static unprocessable(message, details, code) {
-    return new _AppError(message, "validation", { httpStatus: 422, details, code });
-  }
-  static timeout(message, details, code) {
-    return new _AppError(message, "timeout", { details, code });
-  }
-  static canceled(message, details, code) {
-    return new _AppError(message, "canceled", { details, code });
-  }
-  static internal(message, cause, details, code) {
-    return new _AppError(message, "infra", { cause, details, code });
-  }
-  static upstream(message, cause, details, code) {
-    return new _AppError(message, "upstream", { cause, details, code });
-  }
-  static serviceUnavailable(message, cause, details, code) {
-    return new _AppError(message, "infra", { httpStatus: 503, cause, details, code });
-  }
-  static from(err, fallback = "Internal error") {
-    return err instanceof _AppError ? err : _AppError.internal(err?.message ?? fallback, err);
-  }
-};
-function normaliseError(e) {
-  if (e instanceof Error) return { name: e.name, message: e.message, stack: e.stack };
-  const hasMessageProp = e != null && typeof e.message !== "undefined";
-  const msg = hasMessageProp ? String(e.message) : String(e);
-  return { name: "Error", message: msg };
-}
-function toReason(e) {
-  if (e instanceof Error) return e;
-  if (e === null) return new Error("null");
-  if (typeof e === "undefined") return new Error("Unknown render error");
-  const maybeMsg = e?.message;
-  if (typeof maybeMsg !== "undefined") return new Error(String(maybeMsg));
-  return new Error(String(e));
-}
-
 // src/logging/utils/index.ts
 var httpStatusFrom = (err, fallback = 500) => err instanceof AppError ? err.httpStatus : fallback;
 var toHttp = (err) => {
@@ -880,39 +878,47 @@ var statusText = (status) => {
 import { match } from "path-to-regexp";
 
 // src/utils/DataServices.ts
+import { performance as performance2 } from "perf_hooks";
 async function callServiceMethod(registry, serviceName, methodName, params, ctx) {
   if (ctx.signal?.aborted) throw AppError.timeout("Request canceled");
   const service = registry[serviceName];
   if (!service) throw AppError.notFound(`Unknown service: ${serviceName}`);
-  const desc = service[methodName];
-  if (!desc) throw AppError.notFound(`Unknown method: ${serviceName}.${methodName}`);
-  const logger = ctx.logger?.child({
+  const method = service[methodName];
+  if (!method) throw AppError.notFound(`Unknown method: ${serviceName}.${methodName}`);
+  const logger = ctx.logger?.child?.({
     component: "service-call",
     service: serviceName,
     method: methodName,
     traceId: ctx.traceId
   });
+  const t0 = performance2.now();
   try {
-    const p = desc.parsers?.params ? desc.parsers.params(params) : params;
-    const data = await desc.handler(p, ctx);
-    const out = desc.parsers?.result ? desc.parsers.result(data) : data;
-    if (typeof out !== "object" || out === null) throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
-    return out;
+    const result = await method(params ?? {}, ctx);
+    if (typeof result !== "object" || result === null) {
+      throw AppError.internal(`Non-object result from ${serviceName}.${methodName}`);
+    }
+    logger?.debug?.({ ms: +(performance2.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)
+        error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : String(err),
+        ms: +(performance2.now() - t0).toFixed(1)
       },
       "Service method failed"
     );
-    throw err;
+    throw err instanceof AppError ? err : err instanceof Error ? AppError.internal(err.message, { cause: err }) : AppError.internal("Unknown error", { details: { err } });
   }
 }
 var isServiceDescriptor = (obj) => {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
-  const maybe = obj;
-  return typeof maybe.serviceName === "string" && typeof maybe.serviceMethod === "string";
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
+  const o = obj;
+  if (typeof o.serviceName !== "string" || typeof o.serviceMethod !== "string") return false;
+  if ("args" in o) {
+    if (o.args === null || typeof o.args !== "object" || Array.isArray(o.args)) return false;
+  }
+  return true;
 };
 
 // src/utils/DataRoutes.ts
@@ -1019,6 +1025,16 @@ var createAuthHook = (routeMatchers, logger) => {
     if (!match2) return;
     const { route } = match2;
     const authConfig = route.attr?.middleware?.auth;
+    req.routeMeta = {
+      path: route.path,
+      appId: route.appId,
+      attr: {
+        middleware: {
+          auth: route.attr?.middleware?.auth
+        },
+        render: route.attr?.render
+      }
+    };
     if (!authConfig) {
       logger.debug("auth", { method: req.method, url: req.url }, "(none)");
       return;
@@ -1103,42 +1119,27 @@ var cspPlugin = (0, import_fastify_plugin.default)(
     fastify.addHook("onRequest", (req, reply, done) => {
       const nonce = generateNonce();
       req.cspNonce = nonce;
+      const headerNameFor = (routeCSP2) => routeCSP2 && typeof routeCSP2 === "object" && routeCSP2.reportOnly || opts.reporting?.reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy";
+      let routeCSP;
       try {
         const routeMatch = findMatchingRoute(matchers, req.url);
-        const routeCSP = routeMatch?.route.attr?.middleware?.csp;
+        routeCSP = routeMatch?.route.attr?.middleware?.csp;
         if (routeCSP === false) {
           done();
           return;
         }
         let finalDirectives = globalDirectives;
-        if (routeCSP && typeof routeCSP === "object") {
-          if (!routeCSP.disabled) {
-            let routeDirectives;
-            if (typeof routeCSP.directives === "function") {
-              const params = routeMatch?.params || {};
-              routeDirectives = routeCSP.directives({
-                url: req.url,
-                params,
-                headers: req.headers,
-                req
-              });
-            } else {
-              routeDirectives = routeCSP.directives || {};
-            }
-            if (routeCSP.mode === "replace") {
-              finalDirectives = routeDirectives;
-            } else {
-              finalDirectives = mergeDirectives(globalDirectives, routeDirectives);
-            }
-          }
-        }
-        let cspHeader;
-        if (routeCSP?.generateCSP) {
-          cspHeader = routeCSP.generateCSP(finalDirectives, nonce, req);
-        } else {
-          cspHeader = generateCSP(finalDirectives, nonce, req);
+        if (routeCSP && typeof routeCSP === "object" && !routeCSP.disabled) {
+          const routeDirectives = typeof routeCSP.directives === "function" ? routeCSP.directives({
+            url: req.url,
+            params: routeMatch?.params || {},
+            headers: req.headers,
+            req
+          }) : routeCSP.directives ?? {};
+          finalDirectives = routeCSP.mode === "replace" ? routeDirectives : mergeDirectives(globalDirectives, routeDirectives);
         }
-        reply.header("Content-Security-Policy", cspHeader);
+        const cspHeader = routeCSP?.generateCSP ? routeCSP.generateCSP(finalDirectives, nonce, req) : generateCSP(finalDirectives, nonce, req);
+        reply.header(headerNameFor(routeCSP), cspHeader);
       } catch (error) {
         logger.error(
           {
@@ -1148,7 +1149,7 @@ var cspPlugin = (0, import_fastify_plugin.default)(
           "CSP plugin error"
         );
         const fallbackHeader = generateCSP(globalDirectives, nonce, req);
-        reply.header("Content-Security-Policy", fallbackHeader);
+        reply.header(headerNameFor(routeCSP), fallbackHeader);
       }
       done();
     });
@@ -2024,20 +2025,21 @@ var SSRServer = (0, import_fastify_plugin3.default)(
 
 // src/CreateServer.ts
 var createServer = async (opts) => {
-  const t0 = performance2.now();
+  const t0 = performance3.now();
   const clientRoot = opts.clientRoot ?? path5.resolve(process.cwd(), "client");
   const app = opts.fastify ?? Fastify({ logger: false });
-  const net = resolveNet(opts.config.server);
-  await app.register(bannerPlugin, {
-    debug: opts.debug,
-    hmr: { host: net.host, port: net.hmrPort }
-  });
+  const fastifyLogger = app.log && app.log.level !== "silent" ? app.log : void 0;
   const logger = createLogger({
     debug: opts.debug,
-    custom: opts.logger,
+    custom: opts.logger ?? fastifyLogger,
     minLevel: process.env.NODE_ENV === "production" ? "info" : "debug",
     includeContext: true
   });
+  const net = resolveNet(opts.config.server);
+  await app.register(bannerPlugin, {
+    debug: opts.debug,
+    hmr: { host: net.host, port: net.hmrPort }
+  });
   const configs = extractBuildConfigs(opts.config);
   const { routes, apps, totalRoutes, durationMs, warnings } = extractRoutes(opts.config);
   const { security, durationMs: securityDuration, hasExplicitCSP } = extractSecurity(opts.config);
@@ -2084,7 +2086,7 @@ var createServer = async (opts) => {
       "Failed to register SSRServer"
     );
   }
-  const t1 = performance2.now();
+  const t1 = performance3.now();
   console.log(`
 ${import_picocolors4.default.bgGreen(import_picocolors4.default.black(` ${CONTENT.TAG} `))} configured in ${(t1 - t0).toFixed(0)}ms
 `);
@@ -2174,7 +2176,24 @@ async function taujsBuild({
     }
   }
 }
+
+// src/logging/Adapters.ts
+var cleanMeta = (m) => m && Object.keys(m).length === 0 ? void 0 : m;
+function messageMetaAdapter(sink) {
+  return {
+    debug: (meta, message) => sink.debug?.(message, cleanMeta(meta)),
+    info: (meta, message) => sink.info?.(message, cleanMeta(meta)),
+    warn: (meta, message) => sink.warn?.(message, cleanMeta(meta)),
+    error: (meta, message) => sink.error?.(message, cleanMeta(meta)),
+    child: (ctx) => messageMetaAdapter(sink.child?.(ctx) ?? sink)
+  };
+}
+function winstonAdapter(winston) {
+  return messageMetaAdapter(winston);
+}
 export {
+  createLogger,
   createServer,
-  taujsBuild
+  taujsBuild,
+  winstonAdapter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taujs/server",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "τjs [ taujs ]",
   "author": "John Smith | Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
   "license": "MIT",