@adviser/cement 0.2.40 → 0.2.41

package/index.js

@@ -1,3 +1,8 @@
+import {
+  ConsoleWriterStream,
+  FanoutWriteStream,
+  utils_exports
+} from "./chunk-USQXEZHL.js";
 import {
   WebSysAbstraction
 } from "./chunk-W2GV5KXV.js";
@@ -26,11 +31,6 @@ import {
   WrapperSysAbstraction,
   envFactory
 } from "./chunk-F5W6VELE.js";
-import {
-  ConsoleWriterStream,
-  FanoutWriteStream,
-  utils_exports
-} from "./chunk-USQXEZHL.js";
 import {
   Utf8EnDecoder,
   Utf8EnDecoderSingleton,
@@ -114,7 +114,16 @@ var LogValue = class {
 function asyncLogValue(val) {
   throw new Error("Not implemented");
 }
-function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
+function logValue(val, ctx) {
+  return logValueInternal(val, __spreadProps(__spreadValues({}, ctx), {
+    state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
+  }));
+}
+function logValueInternal(val, ctx) {
+  var _a, _b;
+  ctx = __spreadProps(__spreadValues({}, ctx), {
+    state: ctx.state || /* @__PURE__ */ new Set([Math.random()])
+  });
   switch (typeof val) {
     case "function":
       return new LogValue(val);
@@ -122,7 +131,7 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
       try {
         const ret = JSON.parse(val);
         if (typeof ret === "object" && ret !== null) {
-          return logValue(ret, state);
+          return logValueInternal(ret, ctx);
         }
       } catch (e) {
         if (val.match(/[\n\r]/)) {
@@ -145,13 +154,15 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
           const decoder = new TextDecoder();
           const asStr = decoder.decode(val);
           const obj = JSON.parse(asStr);
-          return logValue(obj, state);
+          return logValueInternal(obj, ctx);
         } catch (e) {
-          return logValue(bin2string(val, 512));
+          return logValueInternal(bin2string(val, 512), ctx);
         }
       }
       if (Array.isArray(val)) {
-        return new LogValue(() => val.map((v) => logValue(v).value()));
+        return new LogValue(
+          () => val.map((v) => logValue(v, __spreadProps(__spreadValues({}, ctx), { state: void 0 })).value())
+        );
       }
       if (val instanceof Headers) {
         return new LogValue(() => Object.fromEntries(val.entries()));
@@ -162,22 +173,25 @@ function logValue(val, state = /* @__PURE__ */ new Set([Math.random()])) {
       if (val instanceof Promise) {
         return new LogValue(() => ">Promise<");
       }
-      if (state.has(val)) {
+      if ((_a = ctx.state) == null ? void 0 : _a.has(val)) {
         return new LogValue(() => "...");
       }
-      state.add(val);
+      (_b = ctx.state) == null ? void 0 : _b.add(val);
       if (typeof val.toJSON === "function") {
         return new LogValue(() => val.toJSON());
       }
       const res = {};
       const typedVal = val;
       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);
           }
         }
       }
@@ -220,6 +234,12 @@ var Result = class _Result {
     if (typeof t === "string") {
       return new ResultError(new Error(t));
     }
+    if (_Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok"));
+      }
+      return t;
+    }
     return new ResultError(t);
   }
   static Is(t) {
@@ -355,6 +375,7 @@ function localStripper(path, restrips, obj) {
 }
 
 // src/uri.ts
+var REQUIRED = 4711;
 function coerceKey(key, def) {
   if (typeof key === "object") {
     const keys = Object.keys(key);
@@ -841,11 +862,66 @@ var LogWriterStream = class {
   }
 };
 
+// src/option.ts
+var Option = class _Option {
+  static Some(t) {
+    return new Some(t);
+  }
+  static None() {
+    return new None();
+  }
+  static Is(t) {
+    return t instanceof _Option;
+  }
+  static From(t) {
+    if (!t) {
+      return new None();
+    }
+    return new Some(t);
+  }
+  IsNone() {
+    return this.is_none();
+  }
+  IsSome() {
+    return this.is_some();
+  }
+  Unwrap() {
+    return this.unwrap();
+  }
+};
+var Some = class extends Option {
+  constructor(_t) {
+    super();
+    this._t = _t;
+  }
+  is_none() {
+    return false;
+  }
+  is_some() {
+    return true;
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var None = class extends Option {
+  is_none() {
+    return true;
+  }
+  is_some() {
+    return false;
+  }
+  unwrap() {
+    throw new Error("None.unwrap");
+  }
+};
+
 // src/log-level-impl.ts
 var LevelHandlerImpl = class {
   constructor() {
     this._globalLevels = /* @__PURE__ */ new Set(["info" /* INFO */, "error" /* ERROR */, "warn" /* WARN */]);
     this._modules = /* @__PURE__ */ new Map();
+    this.ignoreAttr = Option.Some(/^_/);
     this.isStackExposed = false;
   }
   enableLevel(level, ...modules) {
@@ -877,6 +953,9 @@ var LevelHandlerImpl = class {
   setExposeStack(enable) {
     this.isStackExposed = !!enable;
   }
+  setIgnoreAttr(re) {
+    this.ignoreAttr = Option.From(re);
+  }
   forModules(level, fnAction, ...modules) {
     for (const m of modules.flat()) {
       if (typeof m !== "string") {
@@ -923,20 +1002,20 @@ function LevelHandlerSingleton() {
 }
 
 // src/logger-impl.ts
-function getLen(value) {
+function getLen(value, lvs) {
   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.size === "number") {
-      return logValue(() => value.size);
+      return logValue(() => value.size, lvs);
     } else if (typeof value.length === "number") {
-      return logValue(() => value.length);
+      return logValue(() => value.length, lvs);
     }
-    return logValue(() => Object.keys(value).length);
+    return logValue(() => Object.keys(value).length, lvs);
   }
-  return logValue(() => -1);
+  return logValue(() => -1, lvs);
 }
 function hash(value) {
   return "not implemented";
@@ -971,6 +1050,11 @@ var YAMLFormatter = class {
     return this._txtEnDe.encode("---\n" + YAML.stringify(attr, null, this._space) + "\n");
   }
 };
+function toLogValueCtx(lvh) {
+  return {
+    ignoreAttr: lvh.ignoreAttr
+  };
+}
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -1020,9 +1104,9 @@ var LoggerImpl = class _LoggerImpl {
     }
     this._attributes = __spreadValues({}, this._withAttributes);
     if (params.levelHandler) {
-      this._levelHandler = params.levelHandler;
+      this.levelHandler = params.levelHandler;
     } else {
-      this._levelHandler = LevelHandlerSingleton();
+      this.levelHandler = LevelHandlerSingleton();
     }
   }
   TxtEnDe() {
@@ -1032,25 +1116,29 @@ var LoggerImpl = class _LoggerImpl {
     return JSON.parse(JSON.stringify(this._attributes, null));
   }
   SetExposeStack(enable) {
-    this._levelHandler.setExposeStack(enable);
+    this.levelHandler.setExposeStack(enable);
     return this;
   }
   EnableLevel(level, ...modules) {
-    this._levelHandler.enableLevel(level, ...modules);
+    this.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level, ...modules) {
-    this._levelHandler.disableLevel(level, ...modules);
+    this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
   Module(key) {
-    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) {
-    this._levelHandler.setDebug(...modules);
+    this.levelHandler.setDebug(...modules);
+    return this;
+  }
+  SetIgnoreAttribute(re) {
+    this.levelHandler.setIgnoreAttr(re);
     return this;
   }
   SetFormatter(formatter) {
@@ -1058,57 +1146,63 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Timestamp() {
-    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString(), toLogValueCtx(this.levelHandler));
     return this;
   }
   Warn() {
-    this._attributes["level"] = logValue("warn" /* WARN */);
+    this._attributes["level"] = logValue("warn" /* WARN */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Log() {
     return this;
   }
   Debug() {
-    this._attributes["level"] = logValue("debug" /* DEBUG */);
+    this._attributes["level"] = logValue("debug" /* DEBUG */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Error() {
-    this._attributes["level"] = logValue("error" /* ERROR */);
+    this._attributes["level"] = logValue("error" /* ERROR */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Info() {
-    this._attributes["level"] = logValue("info" /* INFO */);
+    this._attributes["level"] = logValue("info" /* INFO */, toLogValueCtx(this.levelHandler));
     return this;
   }
   Err(err) {
     var _a;
+    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((_a = err.stack) == null ? void 0 : _a.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(
+          (_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()),
+          toLogValueCtx(this.levelHandler)
+        );
       }
     } else {
-      this._attributes["error"] = logValue("" + err);
+      this.Any(key, err);
     }
     return this;
   }
   WithLevel(l) {
-    this._attributes["level"] = logValue(l);
+    this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
   Ref(key, action) {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action);
+      this._attributes[key] = logValue(action, 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;
   }
@@ -1158,18 +1252,20 @@ var LoggerImpl = class _LoggerImpl {
   }
   Result(key, res) {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok());
+      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
   Len(value, key = "len") {
-    this._attributes[key] = getLen(value);
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
   Hash(value, key = "hash") {
-    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;
   }
   Url(url, key = "url") {
@@ -1178,7 +1274,7 @@ var LoggerImpl = class _LoggerImpl {
   }
   coerceKey(key, value) {
     if (typeof key === "string") {
-      this._attributes[key] = logValue(value);
+      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
       this.Pair(key);
     }
@@ -1192,7 +1288,7 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Dur(key, nsec) {
-    this._attributes[key] = logValue(`${nsec}ms`);
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
   Uint64(key, value) {
@@ -1212,7 +1308,7 @@ var LoggerImpl = class _LoggerImpl {
       new _LoggerImpl({
         logWriter: this._logWriter,
         sys: this._sys,
-        levelHandler: this._levelHandler,
+        levelHandler: this.levelHandler,
         formatter: this._formatter,
         withAttributes: __spreadValues({
           module: this._attributes["module"]
@@ -1231,11 +1327,11 @@ var LoggerImpl = class _LoggerImpl {
   Msg(...args) {
     const fnError = this._resetAttributes(() => {
       var _a, _b;
-      const doWrite = this._levelHandler.isEnabled(
+      const doWrite = this.levelHandler.isEnabled(
         (_a = toLogValue(this._attributes["level"])) == null ? void 0 : _a.value(),
         (_b = toLogValue(this._attributes["module"])) == null ? void 0 : _b.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"];
@@ -1258,6 +1354,7 @@ var LoggerImpl = class _LoggerImpl {
 var WithLoggerBuilder = class {
   constructor(li) {
     this._li = li;
+    this.levelHandler = li.levelHandler;
   }
   TxtEnDe() {
     return this._li.TxtEnDe();
@@ -1270,7 +1367,11 @@ var WithLoggerBuilder = class {
     return __spreadValues({}, this._li._attributes);
   }
   SetExposeStack(enable) {
-    this._li._levelHandler.setExposeStack(enable);
+    this._li.levelHandler.setExposeStack(enable);
+    return this;
+  }
+  SetIgnoreAttribute(re) {
+    this._li.levelHandler.setIgnoreAttr(re);
     return this;
   }
   SetFormatter(fmt) {
@@ -1278,11 +1379,11 @@ var WithLoggerBuilder = class {
     return this;
   }
   EnableLevel(level, ...modules) {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level, ...modules) {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   Module(key) {
@@ -1481,54 +1582,6 @@ function MockLogger(params) {
   };
 }
 
-// src/option.ts
-var Option = class _Option {
-  static Some(t) {
-    return new Some(t);
-  }
-  static None() {
-    return new None();
-  }
-  static Is(t) {
-    return t instanceof _Option;
-  }
-  IsNone() {
-    return this.is_none();
-  }
-  IsSome() {
-    return this.is_some();
-  }
-  Unwrap() {
-    return this.unwrap();
-  }
-};
-var Some = class extends Option {
-  constructor(_t) {
-    super();
-    this._t = _t;
-  }
-  is_none() {
-    return false;
-  }
-  is_some() {
-    return true;
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var None = class extends Option {
-  is_none() {
-    return true;
-  }
-  is_some() {
-    return false;
-  }
-  unwrap() {
-    throw new Error("None.unwrap");
-  }
-};
-
 // src/tracer.ts
 var Metric = class {
   constructor(path) {
@@ -1735,6 +1788,7 @@ export {
   MutableURL,
   None,
   Option,
+  REQUIRED,
   RandomMode,
   RandomService,
   ResolveOnce,