@onesub/server 0.23.3 → 0.24.0

package/dist/__tests__/log-format.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * formatLogArgs — the security properties of log rendering.
+ *
+ * These live here rather than in `logger.test.ts` because they are properties of a
+ * pure function from arguments to a string. `logger.ts` holds process-global state
+ * and needs `setLogger` juggling; nothing that carries a security claim should
+ * depend on that.
+ *
+ * The central claim is one property, asserted over a hostile matrix rather than
+ * case by case: **no byte supplied by a caller can begin a line.** Everything else
+ * here is either a corollary or a guard against the formatter throwing on input it
+ * will genuinely receive.
+ */
+export {};
+//# sourceMappingURL=log-format.test.d.ts.map

package/dist/__tests__/log-format.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-format.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/log-format.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/__tests__/logger.test.d.ts

@@ -1,11 +1,18 @@
 /**
- * The process-wide logger, and specifically that a caller cannot forge log lines.
+ * The process-wide logger: routing, and the shape of what reaches the sink.
  *
- * Much of what this server logs is attacker-influenced — `userId` arrives in the
- * request body, and bundle ids, package names and receipt previews come out of
- * submitted receipts. A newline in any of those would let a caller end the current
- * line and write an entry of their own, and these logs are what support and fraud
- * decisions get read from.
+ * The escaping and rendering details moved to `log-format.test.ts`, which tests them
+ * as properties of a pure function over a hostile matrix rather than one case at a
+ * time. What is left here is what only this module can answer: that each level goes
+ * where it should, and that a sink receives **exactly one string argument**.
+ *
+ * That last one is the load-bearing assertion. It is the contract every documented
+ * sink depends on — `pino` treats a second argument as a printf interpolation
+ * parameter, not as structured fields, so anything "helpfully" passing fields
+ * alongside the message would silently degrade for the sink this package recommends
+ * for production. There is also then no shape for a JSON serialiser to drop: an
+ * `Error` passed as an object would serialise to `{}`, because its own properties
+ * are non-enumerable.
  */
 export {};
 //# sourceMappingURL=logger.test.d.ts.map

package/dist/__tests__/logger.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/logger.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/logger.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/index.cjs

@@ -170,21 +170,131 @@ at+qIxUCMG1mihDK1A3UT82NQz60imOlM27jbdoXt2QfyFMm+YhidDkLF1vLUagM
 -----END CERTIFICATE-----`;
 var APPLE_ROOT_CA_PEMS = [APPLE_ROOT_CA_G3_PEM];
 
+// src/log-format.ts
+var LOG_CONTINUATION = "\n    | ";
+var BARE_VALUE = /^[\w.:/@+-]+$/;
+var LINE_TERMINATORS = /\r\n|\r|\n|\u2028|\u2029/;
+var MAX_CAUSE_DEPTH = 2;
+var MAX_AGGREGATE_ERRORS = 3;
+function esc(value) {
+  return value.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escQuoted(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function renderValue(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "number":
+    case "boolean":
+      return String(value);
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return BARE_VALUE.test(value) ? value : `"${escQuoted(value)}"`;
+    case "object":
+      try {
+        return `"${escQuoted(JSON.stringify(value) ?? "null")}"`;
+      } catch {
+        return '"[unserialisable]"';
+      }
+    default:
+      try {
+        return `"${escQuoted(String(value))}"`;
+      } catch {
+        return '"[unrenderable]"';
+      }
+  }
+}
+function renderFields(fields) {
+  const pairs = [];
+  let err2;
+  for (const key of Object.keys(fields)) {
+    let value;
+    try {
+      value = fields[key];
+    } catch {
+      pairs.push(`${esc(key)}="[threw]"`);
+      continue;
+    }
+    if (key === "err") {
+      err2 = value;
+      continue;
+    }
+    const rendered = renderValue(value);
+    if (rendered !== void 0) pairs.push(`${esc(key)}=${rendered}`);
+  }
+  return { pairs, err: err2 };
+}
+function renderStack(stack) {
+  if (!stack) return "";
+  const lines = stack.split(LINE_TERMINATORS);
+  const firstFrame = lines.findIndex((line) => /^\s+at\s/.test(line));
+  const frames = firstFrame === -1 ? [] : lines.slice(firstFrame);
+  return frames.map((line) => LOG_CONTINUATION + esc(line.trim())).join("");
+}
+function renderError(value, depth = 0) {
+  if (!(value instanceof Error)) {
+    const rendered = renderValue(typeof value === "string" ? value : String(value));
+    return { pairs: [`err.msg=${rendered ?? '"[unrenderable]"'}`], lines: "" };
+  }
+  const pairs = [`err=${renderValue(value.name) ?? "Error"}`];
+  const message = renderValue(value.message);
+  if (message !== void 0) pairs.push(`err.msg=${message}`);
+  let lines = renderStack(value.stack);
+  if (depth < MAX_CAUSE_DEPTH && value.cause !== void 0 && value.cause !== null) {
+    const cause = renderError(value.cause, depth + 1);
+    lines += LOG_CONTINUATION + `cause: ${cause.pairs.join(" ")}` + cause.lines;
+  }
+  if (value instanceof AggregateError && Array.isArray(value.errors)) {
+    for (const inner of value.errors.slice(0, MAX_AGGREGATE_ERRORS)) {
+      const rendered = renderError(inner, MAX_CAUSE_DEPTH);
+      lines += LOG_CONTINUATION + `also: ${rendered.pairs.join(" ")}`;
+    }
+  }
+  return { pairs, lines };
+}
+function formatLogArgs(args) {
+  const words = [];
+  const pairs = [];
+  let errorLines = "";
+  for (const arg of args) {
+    if (typeof arg === "string") {
+      words.push(esc(arg));
+      continue;
+    }
+    if (arg instanceof Error) {
+      const rendered2 = renderError(arg);
+      pairs.push(...rendered2.pairs);
+      errorLines += rendered2.lines;
+      continue;
+    }
+    if (arg !== null && typeof arg === "object" && !Array.isArray(arg)) {
+      const { pairs: fieldPairs, err: err2 } = renderFields(arg);
+      pairs.push(...fieldPairs);
+      if (err2 !== void 0) {
+        const rendered2 = renderError(err2);
+        pairs.push(...rendered2.pairs);
+        errorLines += rendered2.lines;
+      }
+      continue;
+    }
+    const rendered = renderValue(arg);
+    if (rendered !== void 0) words.push(rendered);
+  }
+  return [words.join(" "), ...pairs].filter((part) => part !== "").join(" ") + errorLines;
+}
+
 // src/logger.ts
 var current = console;
 function setLogger(logger) {
   if (logger) current = logger;
 }
-function escapeLineBreaks(value) {
-  return value.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function scrub(args) {
-  return args.map((arg) => typeof arg === "string" ? escapeLineBreaks(arg) : arg);
-}
 var log = {
-  info: (...args) => current.info(...scrub(args)),
-  warn: (...args) => current.warn(...scrub(args)),
-  error: (...args) => current.error(...scrub(args))
+  info: (...args) => current.info(formatLogArgs(args)),
+  warn: (...args) => current.warn(formatLogArgs(args)),
+  error: (...args) => current.error(formatLogArgs(args))
 };
 
 // src/http.ts