@adviser/cement 0.2.40 → 0.2.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adviser/cement",
-  "version": "0.2.40",
+  "version": "0.2.42",
   "description": "better try/catch/finally handling",
   "main": "index.js",
   "type": "module",
@@ -49,7 +49,7 @@
     "@vitest/browser": "^2.1.1",
     "esbuild-plugin-replace": "^1.4.0",
     "esbuild-plugin-resolve": "^2.0.0",
-    "eslint": "9.15.0",
+    "eslint": "9.17.0",
     "prettier": "^3.3.3",
     "tsup": "^8.3.0",
     "tsx": "^4.19.1",

package/src/http_header.ts

@@ -0,0 +1,161 @@
+export class HeadersImpl extends Headers {
+  readonly _headers: Map<string, string>;
+
+  constructor(init: Map<string, string>) {
+    super();
+    this._headers = init;
+  }
+
+  [Symbol.iterator](): HeadersIterator<[string, string]> {
+    return this.entries();
+  }
+
+  entries(): HeadersIterator<[string, string]> {
+    return this._headers.entries();
+  }
+  keys(): HeadersIterator<string> {
+    return this._headers.keys();
+  }
+  values(): HeadersIterator<string> {
+    return this._headers.values();
+  }
+
+  append(key: string, value: string | string[] | undefined): HeadersImpl {
+    const values = this._headers.get(key);
+    if (typeof value === "undefined") {
+      value = "";
+    }
+    if (Array.isArray(value)) {
+      this._headers.set(key, [values, ...value].filter((i) => i).join(", "));
+    } else {
+      this._headers.set(key, [values, value].filter((i) => i).join(", "));
+    }
+    return this;
+  }
+}
+
+export class HttpHeader {
+  readonly _headers: Map<string, string[]> = new Map<string, string[]>();
+
+  static from(headers?: HeadersInit | NodeJS.Dict<string | string[]> | Headers): HttpHeader {
+    const h = new HttpHeader();
+    if (headers) {
+      if (Array.isArray(headers)) {
+        for (const [k, v] of headers) {
+          if (v) {
+            h.Add(k, v);
+          }
+        }
+      } else if (headers instanceof Headers) {
+        for (const [k, v] of headers.entries()) {
+          if (v) {
+            h.Add(
+              k,
+              v.split(",").map((v) => v.trim()),
+            );
+          }
+        }
+      } else {
+        for (const k in headers) {
+          const v = headers[k];
+          if (v) {
+            h.Add(k, v);
+          }
+        }
+      }
+    }
+    return h;
+  }
+
+  _asStringString(): Map<string, string> {
+    const ret = new Map<string, string>();
+    for (const [key, values] of this._headers) {
+      ret.set(key, values.join(", "));
+    }
+    return ret;
+  }
+
+  _key(key: string): string {
+    return key.toLowerCase();
+  }
+  Values(key: string): string[] {
+    const values = this._headers.get(this._key(key));
+    return values || [];
+  }
+  Get(key: string): string | undefined {
+    const values = this._headers.get(this._key(key));
+    if (values === undefined || values.length === 0) {
+      return undefined;
+    }
+    return values[0];
+  }
+  Set(key: string, valueOr: string | string[]): HttpHeader {
+    const value = Array.isArray(valueOr) ? valueOr : [valueOr];
+    this._headers.set(this._key(key), value);
+    return this;
+  }
+  Add(key: string, value: string | string[] | undefined): HttpHeader {
+    if (typeof value === "undefined") {
+      return this;
+    }
+    const vs = Array.isArray(value) ? value : [value];
+    const values = this._headers.get(this._key(key));
+    if (values === undefined) {
+      this._headers.set(this._key(key), vs);
+    } else {
+      values.push(...vs);
+    }
+    return this;
+  }
+  Del(ey: string): HttpHeader {
+    this._headers.delete(this._key(ey));
+    return this;
+  }
+  Items(): [string, string[]][] {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return Array.from(this._headers).filter(([_, vs]) => vs.length > 0);
+  }
+  SortItems(): [string, string[]][] {
+    return this.Items().sort(([[a]], [[b]]) => a.localeCompare(b));
+  }
+  Clone(): HttpHeader {
+    const clone = new HttpHeader();
+    for (const [key, values] of this._headers.entries()) {
+      clone._headers.set(key, values.slice());
+    }
+    return clone;
+  }
+  AsRecordStringStringArray(): Record<string, string[]> {
+    const obj: Record<string, string[]> = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = [...values];
+    }
+    return obj;
+  }
+  AsRecordStringString(): Record<string, string> {
+    const obj: Record<string, string> = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values.join(", ");
+    }
+    return obj;
+  }
+  AsHeaderInit(): HeadersInit {
+    const obj: HeadersInit = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values[0];
+    }
+    return obj;
+  }
+  AsHeaders(): Headers {
+    return new HeadersImpl(this._asStringString());
+  }
+  Merge(other?: HttpHeader): HttpHeader {
+    const ret = this.Clone();
+    if (other) {
+      for (const [key, values] of other.Items()) {
+        ret.Add(key, values);
+      }
+    }
+    return ret;
+  }
+}

package/src/index.ts

@@ -19,4 +19,5 @@ export * from "./crypto.js";
 export * from "./base-sys-abstraction.js";
 export * from "./bin2text.js";
 export * from "./version.js";
+export * from "./http_header.js";
 export * as utils from "./utils/index.js";

package/src/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@adviser/cement",
-  "version": "0.2.40",
+  "version": "0.2.42",
   "exports": {
     ".": "./index.ts",
     "./web": "./web/index.ts",

package/src/log-level-impl.ts

@@ -1,8 +1,11 @@
 import { LevelHandler, Level } from "./logger.js";
+import { Option } from "./option.js";
 
 export class LevelHandlerImpl implements LevelHandler {
   readonly _globalLevels: Set<Level> = new Set<Level>([Level.INFO, Level.ERROR, Level.WARN]);
   readonly _modules: Map<string, Set<Level>> = new Map<string, Set<Level>>();
+
+  ignoreAttr: Option<RegExp> = Option.Some(/^_/);
   isStackExposed = false;
   enableLevel(level: Level, ...modules: string[]): void {
     if (modules.length == 0) {
@@ -35,6 +38,10 @@ export class LevelHandlerImpl implements LevelHandler {
     this.isStackExposed = !!enable;
   }
 
+  setIgnoreAttr(re?: RegExp): void {
+    this.ignoreAttr = Option.From(re);
+  }
+
   forModules(level: Level, fnAction: (p: string) => void, ...modules: (string | string[])[]): void {
     for (const m of modules.flat()) {
       if (typeof m !== "string") {

package/src/logger-impl.ts

@@ -18,6 +18,7 @@ import {
   LogFormatter,
   LogValueArg,
   HttpType,
+  LogValueState,
 } from "./logger.js";
 import { WebSysAbstraction } from "./web/web-sys-abstraction.js";
 import { SysAbstraction } from "./sys-abstraction.js";
@@ -29,20 +30,20 @@ import { LogWriterStream } from "./log-writer-impl.js";
 import { TxtEnDecoder, Utf8EnDecoderSingleton } from "./txt-en-decoder.js";
 import { LevelHandlerSingleton } from "./log-level-impl.js";
 
-function getLen(value: unknown): LogValue {
+function getLen(value: unknown, lvs: LogValueState): LogValue {
   if (Array.isArray(value)) {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "string") {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "object" && value !== null) {
     if (typeof (value as Sized).size === "number") {
-      return logValue(() => (value as Sized).size);
+      return logValue(() => (value as Sized).size, lvs);
     } else if (typeof (value as Lengthed).length === "number") {
-      return logValue(() => (value as Lengthed).length);
+      return logValue(() => (value as Lengthed).length, lvs);
     }
-    return logValue(() => Object.keys(value).length);
+    return logValue(() => Object.keys(value).length, lvs);
   }
-  return logValue(() => -1);
+  return logValue(() => -1, lvs);
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -100,12 +101,18 @@ export interface LoggerImplParams {
   readonly formatter?: LogFormatter;
 }
 
+function toLogValueCtx(lvh: LevelHandler): LogValueState {
+  return {
+    ignoreAttr: lvh.ignoreAttr,
+  };
+}
+
 export class LoggerImpl implements Logger {
   readonly _sys: SysAbstraction;
   readonly _attributes: LogSerializable = {};
   readonly _withAttributes: LogSerializable;
   readonly _logWriter: LogWriterStream;
-  readonly _levelHandler: LevelHandler;
+  readonly levelHandler: LevelHandler;
   readonly _txtEnDe: TxtEnDecoder;
   _formatter: LogFormatter;
   // readonly _id: string = "logger-" + Math.random().toString(36)
@@ -157,9 +164,9 @@ export class LoggerImpl implements Logger {
     }
     this._attributes = { ...this._withAttributes };
     if (params.levelHandler) {
-      this._levelHandler = params.levelHandler;
+      this.levelHandler = params.levelHandler;
     } else {
-      this._levelHandler = LevelHandlerSingleton();
+      this.levelHandler = LevelHandlerSingleton();
     }
     // console.log("LoggerImpl", this._id, this._attributes, this._withAttributes)
   }
@@ -182,27 +189,32 @@ export class LoggerImpl implements Logger {
   }
 
   SetExposeStack(enable?: boolean): Logger {
-    this._levelHandler.setExposeStack(enable);
+    this.levelHandler.setExposeStack(enable);
     return this;
   }
 
   EnableLevel(level: Level, ...modules: string[]): Logger {
-    this._levelHandler.enableLevel(level, ...modules);
+    this.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level: Level, ...modules: string[]): Logger {
-    this._levelHandler.disableLevel(level, ...modules);
+    this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
 
   Module(key: string): Logger {
-    this._attributes["module"] = logValue(key);
-    this._withAttributes["module"] = logValue(key);
+    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
   SetDebug(...modules: (string | string[])[]): Logger {
-    this._levelHandler.setDebug(...modules);
+    this.levelHandler.setDebug(...modules);
+    return this;
+  }
+
+  SetIgnoreAttribute(re?: RegExp): Logger {
+    this.levelHandler.setIgnoreAttr(re);
     return this;
   }
 
@@ -212,57 +224,63 @@ export class LoggerImpl implements Logger {
   }
 
   Timestamp(): Logger {
-    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString(), toLogValueCtx(this.levelHandler));
     return this;
   }
   Warn(): Logger {
-    this._attributes["level"] = logValue(Level.WARN);
+    this._attributes["level"] = logValue(Level.WARN, toLogValueCtx(this.levelHandler));
     return this;
   }
   Log(): Logger {
     return this;
   }
   Debug(): Logger {
-    this._attributes["level"] = logValue(Level.DEBUG);
+    this._attributes["level"] = logValue(Level.DEBUG, toLogValueCtx(this.levelHandler));
     return this;
   }
   Error(): Logger {
-    this._attributes["level"] = logValue(Level.ERROR);
+    this._attributes["level"] = logValue(Level.ERROR, toLogValueCtx(this.levelHandler));
     return this;
   }
   Info(): Logger {
-    this._attributes["level"] = logValue(Level.INFO);
+    this._attributes["level"] = logValue(Level.INFO, toLogValueCtx(this.levelHandler));
     return this;
   }
   Err(err: unknown | Result<unknown> | Error): Logger {
+    let key = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        this.Result("noerror", err);
+        key = "noerror";
+        err = err.Ok();
       } else {
-        this.Result("error", err);
+        err = err.Err();
       }
-    } else if (err instanceof Error) {
-      this._attributes["error"] = logValue(err.message);
-      if (this._levelHandler.isStackExposed) {
-        this._attributes["stack"] = logValue(err.stack?.split("\n").map((s) => s.trim()));
+    }
+    if (err instanceof Error) {
+      this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
+      if (this.levelHandler.isStackExposed) {
+        this._attributes["stack"] = logValue(
+          err.stack?.split("\n").map((s) => s.trim()),
+          toLogValueCtx(this.levelHandler),
+        );
       }
     } else {
-      this._attributes["error"] = logValue("" + err);
+      this.Any(key, err as LogSerializable);
     }
     return this;
   }
   WithLevel(l: Level): Logger {
-    this._attributes["level"] = logValue(l);
+    this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
 
   Ref(key: string, action: { toString: () => string } | FnSerialized): Logger {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action as FnSerialized);
+      this._attributes[key] = logValue(action as FnSerialized, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key] = logValue(() => action.toString());
+      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key] = logValue("INVALID REF");
+      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
@@ -319,7 +337,7 @@ export class LoggerImpl implements Logger {
 
   Result<T>(key: string, res: Result<T, Error>): Logger {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok() as Serialized);
+      this._attributes[key] = logValue(res.Ok() as Serialized, toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
@@ -327,12 +345,14 @@ export class LoggerImpl implements Logger {
   }
 
   Len(value: unknown, key = "len"): Logger {
-    this._attributes[key] = getLen(value);
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
 
   Hash(value: unknown, key = "hash"): Logger {
-    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
+    this._attributes[key] = asyncLogValue(
+      async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`,
+    );
     return this;
   }
 
@@ -343,7 +363,7 @@ export class LoggerImpl implements Logger {
 
   private coerceKey(key: string | Record<string, unknown>, value?: unknown): void {
     if (typeof key === "string") {
-      this._attributes[key] = logValue(value as LogValueArg);
+      this._attributes[key] = logValue(value as LogValueArg, toLogValueCtx(this.levelHandler));
     } else {
       this.Pair(key);
     }
@@ -360,7 +380,7 @@ export class LoggerImpl implements Logger {
     return this;
   }
   Dur(key: string, nsec: number): Logger {
-    this._attributes[key] = logValue(`${nsec}ms`);
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     // new Intl.DurationFormat("en", { style: "narrow" }).format(nsec);
     return this;
   }
@@ -385,7 +405,7 @@ export class LoggerImpl implements Logger {
       new LoggerImpl({
         logWriter: this._logWriter,
         sys: this._sys,
-        levelHandler: this._levelHandler,
+        levelHandler: this.levelHandler,
         formatter: this._formatter,
         withAttributes: {
           module: this._attributes["module"],
@@ -407,11 +427,11 @@ export class LoggerImpl implements Logger {
 
   Msg(...args: string[]): AsError {
     const fnError = this._resetAttributes(() => {
-      const doWrite = this._levelHandler.isEnabled(
+      const doWrite = this.levelHandler.isEnabled(
         toLogValue(this._attributes["level"])?.value(),
         toLogValue(this._attributes["module"])?.value(),
       );
-      this._attributes["msg"] = logValue(args.join(" "));
+      this._attributes["msg"] = logValue(args.join(" "), toLogValueCtx(this.levelHandler));
       const msg = this._attributes["msg"].value();
       if (typeof msg === "string" && !msg.trim().length) {
         delete this._attributes["msg"];
@@ -434,8 +454,10 @@ export class LoggerImpl implements Logger {
 
 class WithLoggerBuilder implements WithLogger {
   readonly _li: LoggerImpl;
+  readonly levelHandler: LevelHandler;
   constructor(li: LoggerImpl) {
     this._li = li;
+    this.levelHandler = li.levelHandler;
   }
 
   TxtEnDe(): TxtEnDecoder {
@@ -452,7 +474,12 @@ class WithLoggerBuilder implements WithLogger {
   }
 
   SetExposeStack(enable?: boolean): WithLogger {
-    this._li._levelHandler.setExposeStack(enable);
+    this._li.levelHandler.setExposeStack(enable);
+    return this;
+  }
+
+  SetIgnoreAttribute(re?: RegExp): WithLogger {
+    this._li.levelHandler.setIgnoreAttr(re);
     return this;
   }
 
@@ -462,11 +489,11 @@ class WithLoggerBuilder implements WithLogger {
   }
 
   EnableLevel(level: Level, ...modules: string[]): WithLogger {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level: Level, ...modules: string[]): WithLogger {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
 

package/src/logger.ts

@@ -1,4 +1,5 @@
 import { bin2string } from "./bin2text.js";
+import { Option } from "./option.js";
 import { Result } from "./result.js";
 import { TxtEnDecoder } from "./txt-en-decoder.js";
 import { CoerceURI } from "./uri.js";
@@ -50,7 +51,25 @@ export function asyncLogValue(val: () => Promise<Serialized>): Promise<LogValue>
 
 export type LogValueArg = LogValue | Serialized | Serialized[] | FnSerialized | undefined | null;
 
-export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown>([Math.random()])): LogValue {
+export interface LogValueState {
+  readonly state?: Set<unknown>;
+  readonly ignoreAttr: Option<RegExp>;
+}
+
+export function logValue(val: LogValueArg, ctx: LogValueState): LogValue {
+  return logValueInternal(val, {
+    ...ctx,
+    state: ctx.state || new Set<unknown>([Math.random()]),
+  });
+}
+
+type LogValueStateInternal = LogValueState & { readonly state: Set<unknown> };
+
+function logValueInternal(val: LogValueArg, ctx: LogValueStateInternal): LogValue {
+  ctx = {
+    ...ctx,
+    state: ctx.state || new Set<unknown>([Math.random()]),
+  } satisfies LogValueStateInternal;
   switch (typeof val) {
     case "function":
       return new LogValue(val);
@@ -58,7 +77,7 @@ export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown
       try {
         const ret = JSON.parse(val);
         if (typeof ret === "object" && ret !== null) {
-          return logValue(ret, state);
+          return logValueInternal(ret, ctx);
         }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
       } catch (e) {
@@ -83,14 +102,16 @@ export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown
           const decoder = new TextDecoder();
           const asStr = decoder.decode(val);
           const obj = JSON.parse(asStr);
-          return logValue(obj, state);
+          return logValueInternal(obj, ctx);
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
         } catch (e) {
-          return logValue(bin2string(val, 512));
+          return logValueInternal(bin2string(val, 512), ctx);
         }
       }
       if (Array.isArray(val)) {
-        return new LogValue(() => (val as Serialized[]).map((v) => logValue(v).value() as Serialized));
+        return new LogValue(() =>
+          (val as Serialized[]).map((v) => logValue(v, { ...ctx, state: undefined }).value() as Serialized),
+        );
       }
       // if (val instanceof Response) {
       //   // my = my.clone() as unknown as LogValue | Serialized[] | null
@@ -109,10 +130,10 @@ export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown
       }
 
       // Duplicate reference found, discard key
-      if (state.has(val)) {
+      if (ctx.state?.has(val)) {
         return new LogValue(() => "...");
       }
-      state.add(val);
+      ctx.state?.add(val);
       if (typeof val.toJSON === "function") {
         return new LogValue(() => val.toJSON());
       }
@@ -120,14 +141,16 @@ export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown
       const res: Record<string, LogValue> = {};
       const typedVal = val as unknown as Record<string, LogValueArg>;
       for (const key in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
+          continue;
+        }
         const element = typedVal[key];
         if (element instanceof LogValue) {
           res[key] = element;
         } else {
           if (typeof element !== "function") {
-            res[key] = logValue(element, state);
+            res[key] = logValueInternal(element, ctx);
           }
-          // res[key] = logValue(element, state);
         }
       }
       // ugly as hell cast but how declare a self-referencing type?
@@ -157,6 +180,8 @@ export interface LevelHandler {
   enableLevel(level: Level, ...modules: string[]): void;
   disableLevel(level: Level, ...modules: string[]): void;
   setExposeStack(enable?: boolean): void;
+  setIgnoreAttr(re?: RegExp): void;
+  ignoreAttr: Option<RegExp>;
   isStackExposed: boolean;
   setDebug(...modules: (string | string[])[]): void;
   isEnabled(ilevel: unknown, module: unknown): boolean;
@@ -165,6 +190,7 @@ export interface LevelHandler {
 export type HttpType = Response | Result<Response> | Request | Result<Request>;
 
 export interface LoggerInterface<R> {
+  readonly levelHandler: LevelHandler;
   TxtEnDe(): TxtEnDecoder;
   Module(key: string): R;
   // if modules is empty, set for all Levels
@@ -174,6 +200,8 @@ export interface LoggerInterface<R> {
   Attributes(): Record<string, unknown>;
 
   SetDebug(...modules: (string | string[])[]): R;
+  // default is /^_/
+  SetIgnoreAttribute(re?: RegExp): R;
   SetExposeStack(enable?: boolean): R;
   SetFormatter(fmt: LogFormatter): R;
 

package/src/option.ts

@@ -11,6 +11,13 @@ export abstract class Option<T> {
     return t instanceof Option;
   }
 
+  static From<T>(t?: T): Option<T> {
+    if (!t) {
+      return new None();
+    }
+    return new Some(t);
+  }
+
   IsNone(): boolean {
     return this.is_none();
   }

package/src/result.ts

@@ -2,10 +2,16 @@ export abstract class Result<T, E = Error> {
   static Ok<T = void>(t: T): Result<T, Error> {
     return new ResultOK(t);
   }
-  static Err<T, E extends Error = Error>(t: E | string): Result<T, E> {
+  static Err<T, E extends Error = Error>(t: E | string | Result<unknown, E>): Result<T, E> {
     if (typeof t === "string") {
       return new ResultError(new Error(t) as E);
     }
+    if (Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok") as E);
+      }
+      return t as Result<T, E>;
+    }
     return new ResultError(t);
   }
   static Is<T>(t: unknown): t is Result<T> {