@ayepi/log 0.1.0

package/dist/middleware.js

@@ -0,0 +1,37 @@
+import { middleware } from "@ayepi/core";
+//#region src/middleware.ts
+/**
+* # @ayepi/log/middleware
+*
+* The frontend-safe **def** for a trace-context middleware. It declares a
+* no-context middleware (it establishes the log context for the downstream chain +
+* handler, but contributes nothing to the payload), with no `node:async_hooks` —
+* that lives in the impl bound via [`logMiddleware.server`](../server) from
+* `@ayepi/log/server`.
+*
+* ```ts
+* // shared.ts (frontend-safe)
+* import { logMiddleware } from '@ayepi/log/middleware';
+* const trace = logMiddleware({ requires: [auth] });
+* spec({ endpoints: { ...trace.group({ … }) } });
+*
+* // server.ts
+* import { logMiddleware } from '@ayepi/log/server';
+* implement(api).middleware(logMiddleware.server(trace, {
+*   context: (ctx, req) => ({ userId: ctx.user.id, path: new URL(req.url).pathname }),
+* }));
+* ```
+*
+* @module
+*/
+/**
+* Create a trace-context middleware **def** — a no-context, frontend-safe contract.
+* Bind the context builder with [`logMiddleware.server(def, { context })`](../server).
+*
+* @typeParam R - inferred from `requires`.
+*/
+function logMiddleware(opts) {
+	return middleware(opts?.name ?? "log", { requires: opts?.requires ?? [] });
+}
+//#endregion
+export { logMiddleware };

package/dist/server.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_internal = require("./internal.cjs");
+const require_middleware = require("./middleware.cjs");
+//#region src/server.ts
+/** Bind a {@link logMiddleware} def to its runtime impl. */
+function logServer(def, opts) {
+	const wrap = opts.logWith ?? require_internal.runWith;
+	const report = (err) => {
+		try {
+			opts.onError?.(err);
+		} catch {}
+	};
+	const run = (io) => {
+		let fields;
+		try {
+			fields = opts.context(io.ctx, io.req);
+		} catch (err) {
+			report(err);
+			return Promise.resolve(io.next());
+		}
+		try {
+			return Promise.resolve(wrap(fields, () => io.next()));
+		} catch (err) {
+			report(err);
+			return Promise.resolve(io.next());
+		}
+	};
+	return {
+		def,
+		impl: run
+	};
+}
+/**
+* The {@link logMiddleware} def factory, augmented with a `.server(def, opts)` binder.
+* Import from `@ayepi/log/server` in your server entry to bind a def created in a
+* frontend-safe spec.
+*/
+const logMiddleware = Object.assign(require_middleware.logMiddleware, { server: logServer });
+//#endregion
+exports.logMiddleware = logMiddleware;

package/dist/server.d.cts

@@ -0,0 +1,36 @@
+import { logMiddleware as logMiddleware$1 } from "./middleware.cjs";
+import { AnyMiddleware, BoundMiddleware, StackCtx } from "@ayepi/core";
+
+//#region src/server.d.ts
+
+/** The `requires` chain of a middleware def. */
+type ReqOf<M extends AnyMiddleware> = M['__req'];
+/**
+ * Server-side options for binding a {@link logMiddleware} def.
+ *
+ * @typeParam M - the def being bound (its `requires` type the `context` callback reads).
+ */
+interface LogMiddlewareServerOptions<M extends AnyMiddleware> {
+  /** Build the context object to push for the downstream chain + handler. */
+  readonly context: (ctx: StackCtx<ReqOf<M>>, req: Request) => object;
+  /** `logWith` to use (default the package's shared trace context). Pass a specific logger's `logWith` to scope it. */
+  readonly logWith?: <T>(add: object, inner: () => T) => T;
+  /**
+   * Observe an error thrown while building or pushing the trace context. The middleware is
+   * **fail-open**: such an error never breaks the request (the chain runs without the context).
+   * Off by default. It must not throw; if it does, the throw is ignored.
+   */
+  readonly onError?: (err: unknown) => void;
+}
+/** Bind a {@link logMiddleware} def to its runtime impl. */
+declare function logServer<M extends AnyMiddleware>(def: M, opts: LogMiddlewareServerOptions<M>): BoundMiddleware<M>;
+/**
+ * The {@link logMiddleware} def factory, augmented with a `.server(def, opts)` binder.
+ * Import from `@ayepi/log/server` in your server entry to bind a def created in a
+ * frontend-safe spec.
+ */
+declare const logMiddleware: typeof logMiddleware$1 & {
+  server: typeof logServer;
+};
+//#endregion
+export { LogMiddlewareServerOptions, logMiddleware };

package/dist/server.d.ts

@@ -0,0 +1,36 @@
+import { logMiddleware as logMiddleware$1 } from "./middleware.js";
+import { AnyMiddleware, BoundMiddleware, StackCtx } from "@ayepi/core";
+
+//#region src/server.d.ts
+
+/** The `requires` chain of a middleware def. */
+type ReqOf<M extends AnyMiddleware> = M['__req'];
+/**
+ * Server-side options for binding a {@link logMiddleware} def.
+ *
+ * @typeParam M - the def being bound (its `requires` type the `context` callback reads).
+ */
+interface LogMiddlewareServerOptions<M extends AnyMiddleware> {
+  /** Build the context object to push for the downstream chain + handler. */
+  readonly context: (ctx: StackCtx<ReqOf<M>>, req: Request) => object;
+  /** `logWith` to use (default the package's shared trace context). Pass a specific logger's `logWith` to scope it. */
+  readonly logWith?: <T>(add: object, inner: () => T) => T;
+  /**
+   * Observe an error thrown while building or pushing the trace context. The middleware is
+   * **fail-open**: such an error never breaks the request (the chain runs without the context).
+   * Off by default. It must not throw; if it does, the throw is ignored.
+   */
+  readonly onError?: (err: unknown) => void;
+}
+/** Bind a {@link logMiddleware} def to its runtime impl. */
+declare function logServer<M extends AnyMiddleware>(def: M, opts: LogMiddlewareServerOptions<M>): BoundMiddleware<M>;
+/**
+ * The {@link logMiddleware} def factory, augmented with a `.server(def, opts)` binder.
+ * Import from `@ayepi/log/server` in your server entry to bind a def created in a
+ * frontend-safe spec.
+ */
+declare const logMiddleware: typeof logMiddleware$1 & {
+  server: typeof logServer;
+};
+//#endregion
+export { LogMiddlewareServerOptions, logMiddleware };

package/dist/server.js

@@ -0,0 +1,39 @@
+import { b as runWith } from "./internal.js";
+import { logMiddleware as logMiddleware$1 } from "./middleware.js";
+//#region src/server.ts
+/** Bind a {@link logMiddleware} def to its runtime impl. */
+function logServer(def, opts) {
+	const wrap = opts.logWith ?? runWith;
+	const report = (err) => {
+		try {
+			opts.onError?.(err);
+		} catch {}
+	};
+	const run = (io) => {
+		let fields;
+		try {
+			fields = opts.context(io.ctx, io.req);
+		} catch (err) {
+			report(err);
+			return Promise.resolve(io.next());
+		}
+		try {
+			return Promise.resolve(wrap(fields, () => io.next()));
+		} catch (err) {
+			report(err);
+			return Promise.resolve(io.next());
+		}
+	};
+	return {
+		def,
+		impl: run
+	};
+}
+/**
+* The {@link logMiddleware} def factory, augmented with a `.server(def, opts)` binder.
+* Import from `@ayepi/log/server` in your server entry to bind a def created in a
+* frontend-safe spec.
+*/
+const logMiddleware = Object.assign(logMiddleware$1, { server: logServer });
+//#endregion
+export { logMiddleware };

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@ayepi/log",
+  "version": "0.1.0",
+  "description": "Structured logging for ayepi — AsyncLocalStorage trace context, console interception, console/file transports, error serialization, middleware",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClickerMonkey/ayepi.git",
+    "directory": "packages/log"
+  },
+  "homepage": "https://github.com/ClickerMonkey/ayepi/tree/main/packages/log#readme",
+  "bugs": {
+    "url": "https://github.com/ClickerMonkey/ayepi/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./file": {
+      "import": {
+        "types": "./dist/file.d.ts",
+        "default": "./dist/file.js"
+      },
+      "require": {
+        "types": "./dist/file.d.cts",
+        "default": "./dist/file.cjs"
+      }
+    },
+    "./middleware": {
+      "import": {
+        "types": "./dist/middleware.d.ts",
+        "default": "./dist/middleware.js"
+      },
+      "require": {
+        "types": "./dist/middleware.d.cts",
+        "default": "./dist/middleware.cjs"
+      }
+    },
+    "./server": {
+      "import": {
+        "types": "./dist/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "require": {
+        "types": "./dist/server.d.cts",
+        "default": "./dist/server.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@ayepi/core": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@ayepi/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.8",
+    "publint": "^0.3.0",
+    "tsdown": "^0.12.0",
+    "vitest": "^2.1.8",
+    "zod": "^4.4.3",
+    "@ayepi/core": "0.1.0"
+  },
+  "keywords": [
+    "ayepi",
+    "logging",
+    "logger",
+    "structured-logging",
+    "async-local-storage",
+    "tracing",
+    "middleware"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage",
+    "publint": "publint"
+  }
+}