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

package/src/builtin/LogRecord.ts

@@ -7,6 +7,8 @@ export interface LogRecord {
   name: string;
   message: string;
   args: unknown[];
+  /** The operation it was written inside — 'blog:PostHandler.publish'. */
+  during?: string | null;
   /** Epoch milliseconds. */
   at: number;
 }

package/src/builtin/Logger.ts

@@ -73,16 +73,22 @@ export class Logger {
   private name: string;
   private color: boolean;
   private carry?: Carry;
+  private during?: () => string | undefined;
 
   constructor(prefix?: string, options?: Omit<LoggerOptions, 'name'>) {
     this.name = prefix ?? 'app';
     this.color = options?.color ?? supportsColor();
     this.carry = options?.carry;
+    this.during = options?.during;
   }
 
   /** Create a child logger with a sub-name. It carries no level of its own either. */
   child(name: string): Logger {
-    return new Logger(`${this.name}:${name}`, { color: this.color, ...(this.carry ? { carry: this.carry } : {}) });
+    return new Logger(`${this.name}:${name}`, {
+      color: this.color,
+      ...(this.carry ? { carry: this.carry } : {}),
+      ...(this.during ? { during: this.during } : {}),
+    });
   }
 
   debug(msg: string, ...args: unknown[]) { this.log('debug', msg, args); }
@@ -92,8 +98,10 @@ export class Logger {
 
   private log(level: string, msg: string, args: unknown[]) {
     if (LEVELS[level as LogLevel] < threshold) return;
+    const during = this.during?.();
     const record: LogRecord = {
       level: level as LogRecord['level'], name: this.name, message: msg, args, at: Date.now(),
+      ...(during ? { during } : {}),
     };
 
     this.carry?.push({ ...record, args: args.map(objectOf) });
@@ -118,13 +126,14 @@ export function formatted(
   const style = LEVEL_STYLE[record.level];
   const time = stamp(record.at);
   const method = record.level;
+  const during = record.during ? ` (${record.during})` : '';
 
   if (color) {
     const c = COLORS[style.color];
-    const prefix = `${COLORS.dim}${time}${COLORS.reset} ${c}${COLORS.bold}${style.badge}${COLORS.reset} ${COLORS.magenta}${record.name}${COLORS.reset}`;
+    const prefix = `${COLORS.dim}${time}${COLORS.reset} ${c}${COLORS.bold}${style.badge}${COLORS.reset} ${COLORS.magenta}${record.name}${COLORS.reset}${COLORS.gray}${during}${COLORS.reset}`;
 
     return { method, text: [prefix, record.message, ...(record.args ?? [])] };
   }
 
-  return { method, text: [`${time} ${style.badge} [${record.name}]`, record.message, ...(record.args ?? [])] };
+  return { method, text: [`${time} ${style.badge} [${record.name}]${during}`, record.message, ...(record.args ?? [])] };
 }

package/src/builtin/LoggerOptions.ts

@@ -9,6 +9,8 @@ export interface LoggerOptions {
    * first lines do and what an app declaring no destination does forever.
    */
   carry?: Carry;
+  /** The operation a line is written inside, asked at each line — the boot hands it over. */
+  during?: () => string | undefined;
   /** Force color on/off. Auto-detected by default. */
   color?: boolean;
 }

package/src/builtin/OwnLoggers.ts

@@ -0,0 +1,21 @@
+import type { Container } from '@fougere/container';
+import type { Logger } from './Logger.js';
+
+/** A class's deps, its `Logger` replaced by one named after it. */
+export type OwnLogger = (className: string, deps: readonly string[]) => string[];
+
+/**
+ * A class asking for `Logger` gets one named after it — `app:blog:PricingService` — under a key of
+ * its own, so the container builds nothing new. A frond that `replaced` it with a class of its own
+ * keeps that class whole: `child()` hands back a bare `Logger`.
+ */
+export function ownLoggers(scope: Container, replaced: boolean): OwnLogger {
+  return (className, deps) => {
+    if (replaced || !deps.includes('Logger')) return [...deps];
+
+    const key = `Logger:${className}`;
+    scope.registerValue(key, scope.resolve<Logger>('Logger').child(className));
+
+    return deps.map((dep) => (dep === 'Logger' ? key : dep));
+  };
+}

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/node.ts

@@ -1,5 +1,5 @@
 /** What Fougere does with a filesystem, minus the scan — that is `@fougere/compiler`. */
-export { setModuleLoader, getModuleLoader } from './loader.js';
+export { setModuleLoader, getModuleLoader, type ModuleLoader } from './loader.js';
 export { configFileIn, loadConfig, loadCascadedConfig, projectRootOf, remotesOf } from './FougereConfig.js';
 export { statedModules } from './StatedModules.js';
 export { defineFrond, loadFrondConfig } from './FrondConfig.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;
-    }
-  };
-}