@fougere/core 0.16.3-alpha.0 → 0.16.4-alpha.0

package/src/builtin/Rendered.ts

@@ -14,6 +14,7 @@ export interface Rendered {
   level: Exclude<LogLevel, 'silent'>;
   name: string;
   message: string;
+  during?: string | null;
   /** Absent on most lines: a message usually carries its own detail. */
   args?: unknown[] | null;
   /** Epoch milliseconds from a logger, a `Date` from an entity that stamped it. */

package/src/dispatch/Facade.ts

@@ -4,6 +4,7 @@ import type { EffectiveOperationsMap } from '../EffectiveOperationsMap.js';
 import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
 import type { PresenterEntry } from '../descriptor/PresenterEntry.js';
 import type { StateShape } from '../wire/StateShape.js';
+import type { OwnLogger } from '../builtin/OwnLoggers.js';
 
 /** What boot resolved around one handler, beyond the handler and the scope it resolves in. */
 export interface Facade {
@@ -25,4 +26,8 @@ export interface Facade {
   middlewares: () => AppMiddleware[];
   /** What a call's `state` may hold in this process. */
   state: StateShape;
+  /** Runs the handler as the operation a line written inside it names. */
+  enterOperation: <R>(label: string, fn: () => Promise<R>) => Promise<R>;
+  /** The handler's deps, its `Logger` named after it. */
+  ownLogger: OwnLogger;
 }

package/src/dispatch/HandlerFacade.ts

@@ -92,16 +92,21 @@ export class HandlerFacade {
     const state = received.crossed ? { ...received.state } : this.facade.state.judge(received.state, entity, op);
     const invocation = received.withState(state);
     const entered = { ...state };
+    const { className, method } = this.effectiveOperations.get(op)!.implementation;
     const context: OperationContext = {
       entity,
       frond: this.facade.frond,
+      handler: className,
       operation: op,
       args: [],
       state: invocation.state,
       invocation,
     };
 
-    return runMiddlewares(this.facade.middlewares(), context, () => this.answer(op, contract, context, invocation, entered));
+    const label = `${this.facade.frond}:${className}.${method}`;
+
+    return runMiddlewares(this.facade.middlewares(), context, () =>
+      this.facade.enterOperation(label, () => this.answer(op, contract, context, invocation, entered)));
   }
 
   /**
@@ -162,7 +167,7 @@ export class HandlerFacade {
 
   private depsOf(handler: HandlerEntry): string[] {
     const { deps } = handler;
-    if (deps.length > 0) return deps;
+    if (deps.length > 0) return this.facade.ownLogger(handler.ctor.name, deps);
 
     return inheritsCrud(handler.ctor)
       ? [repositoryKeyOf(subjectOf(handler.ctor, handler.address))]

package/src/index.ts

@@ -110,7 +110,6 @@ export { type Pipe } from './wire/Pipe.js';
 export { callValueOf } from './contract.js';
 export { toHttpError } from './wire/http-error.js';
 export { toPublicError } from './contract.js';
-export { loggerMiddleware } from './wire/loggerMiddleware.js';
 export { Carry } from './builtin/Carry.js';
 export { Logger, envLevel, formatted, logLevel, setLogLevel } from './builtin/Logger.js';
 export type { LogRecord } from './builtin/LogRecord.js';

package/src/wire/OperationContext.ts

@@ -7,6 +7,8 @@ export interface OperationContext {
    * one a reader groups by first. Absent only where no frond claims the call.
    */
   frond?: string;
+  /** The class that answers, as the scan named it — `PostHandler`. */
+  handler?: string;
   /** Operation name (e.g. 'create', 'findById', 'searchByTitle'). */
   operation: string;
   /** Arguments passed to the operation. */

package/dist/wire/loggerMiddleware.d.ts

@@ -1,8 +0,0 @@
-/**
- * Logger middleware — logs every operation with timing.
- */
-import type { AppMiddleware } from './AppMiddleware.js';
-import type { Logger } from '../builtin/Logger.js';
-/** Create a logger middleware that logs operation entry, exit, and errors. */
-export declare function loggerMiddleware(logger: Logger): AppMiddleware;
-//# sourceMappingURL=loggerMiddleware.d.ts.map

package/dist/wire/loggerMiddleware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loggerMiddleware.d.ts","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAqB9D"}

package/dist/wire/loggerMiddleware.js

@@ -1,25 +0,0 @@
-import { CARRIES_LINE } from '../builtin/LogLine.js';
-/** Create a logger middleware that logs operation entry, exit, and errors. */
-export function loggerMiddleware(logger) {
-    return async (ctx, next) => {
-        // An op that CARRIES a line writes none: it is dispatched, so logging it announces a
-        // line inside the announcement of one — `Emission cycle: logLine → logLine`, which is
-        // the emission catching what `onLog`'s try/catch used to swallow.
-        if (CARRIES_LINE.has(ctx.entity))
-            return next();
-        const start = performance.now();
-        logger.info(`${ctx.entity}.${ctx.operation}`);
-        try {
-            const result = await next();
-            const ms = (performance.now() - start).toFixed(1);
-            logger.info(`${ctx.entity}.${ctx.operation} (${ms}ms)`);
-            return result;
-        }
-        catch (err) {
-            const ms = (performance.now() - start).toFixed(1);
-            logger.error(`${ctx.entity}.${ctx.operation} (${ms}ms)`, err);
-            throw err;
-        }
-    };
-}
-//# sourceMappingURL=loggerMiddleware.js.map

package/dist/wire/loggerMiddleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loggerMiddleware.js","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,8EAA8E;AAC9E,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QACzB,qFAAqF;QACrF,sFAAsF;QACtF,kEAAkE;QAClE,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QAEhD,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YAC5B,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC;YAExD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;YAC9D,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/src/wire/loggerMiddleware.ts

@@ -1,30 +0,0 @@
-/**
- * Logger middleware — logs every operation with timing.
- */
-import type { AppMiddleware } from './AppMiddleware.js';
-import type { Logger } from '../builtin/Logger.js';
-import { CARRIES_LINE } from '../builtin/LogLine.js';
-
-/** Create a logger middleware that logs operation entry, exit, and errors. */
-export function loggerMiddleware(logger: Logger): AppMiddleware {
-  return async (ctx, next) => {
-    // An op that CARRIES a line writes none: it is dispatched, so logging it announces a
-    // line inside the announcement of one — `Emission cycle: logLine → logLine`, which is
-    // the emission catching what `onLog`'s try/catch used to swallow.
-    if (CARRIES_LINE.has(ctx.entity)) return next();
-
-    const start = performance.now();
-    logger.info(`${ctx.entity}.${ctx.operation}`);
-    try {
-      const result = await next();
-      const ms = (performance.now() - start).toFixed(1);
-      logger.info(`${ctx.entity}.${ctx.operation} (${ms}ms)`);
-
-      return result;
-    } catch (err) {
-      const ms = (performance.now() - start).toFixed(1);
-      logger.error(`${ctx.entity}.${ctx.operation} (${ms}ms)`, err);
-      throw err;
-    }
-  };
-}