@adviser/cement 0.2.45 → 0.3.0

package/index.js

@@ -181,16 +181,16 @@ function logValueInternal(val, ctx) {
       }
       const res = {};
       const typedVal = val;
-      for (const key in typedVal) {
-        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
+      for (const key2 in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key2)) {
           continue;
         }
-        const element = typedVal[key];
+        const element = typedVal[key2];
         if (element instanceof LogValue) {
-          res[key] = element;
+          res[key2] = element;
         } else {
           if (typeof element !== "function") {
-            res[key] = logValueInternal(element, ctx);
+            res[key2] = logValueInternal(element, ctx);
           }
         }
       }
@@ -468,37 +468,37 @@ function localStripper(path, restrips, obj) {
     return obj.map((i) => localStripper(path, restrips, i));
   }
   const ret = { ...obj };
-  const matcher = (key, nextPath) => {
+  const matcher = (key2, nextPath) => {
     for (const re of restrips) {
-      if (re.test(key) || re.test(nextPath)) {
+      if (re.test(key2) || re.test(nextPath)) {
         return true;
       }
     }
     return false;
   };
-  for (const key in ret) {
-    if (Object.prototype.hasOwnProperty.call(ret, key)) {
+  for (const key2 in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key2)) {
       let nextPath;
       if (path) {
-        nextPath = [path, key].join(".");
+        nextPath = [path, key2].join(".");
       } else {
-        nextPath = key;
+        nextPath = key2;
       }
-      if (matcher(key, nextPath)) {
-        delete ret[key];
+      if (matcher(key2, nextPath)) {
+        delete ret[key2];
         continue;
       }
-      if (typeof ret[key] === "object") {
-        if (Array.isArray(ret[key])) {
-          ret[key] = ret[key].reduce((acc, v, i) => {
-            const toDelete = matcher(key, `${nextPath}[${i}]`);
+      if (typeof ret[key2] === "object") {
+        if (Array.isArray(ret[key2])) {
+          ret[key2] = ret[key2].reduce((acc, v, i) => {
+            const toDelete = matcher(key2, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
             }
             return acc;
           }, []);
         } else {
-          ret[key] = localStripper(nextPath, restrips, ret[key]);
+          ret[key2] = localStripper(nextPath, restrips, ret[key2]);
         }
       }
     }
@@ -507,16 +507,29 @@ function localStripper(path, restrips, obj) {
 }
 
 // src/uri.ts
-var REQUIRED = 4711;
-function coerceKey(key, def) {
-  if (typeof key === "object") {
-    const keys = Object.keys(key);
+var _REQUIRED = class {
+  constructor() {
+    this.val = "REQUIRED";
+  }
+};
+var _OPTIONAL = class {
+  constructor() {
+    this.val = "OPTIONAL";
+  }
+};
+var key = {
+  REQUIRED: new _REQUIRED(),
+  OPTIONAL: new _OPTIONAL()
+};
+function coerceKey(key2, def) {
+  if (typeof key2 === "object") {
+    const keys = Object.keys(key2);
     if (keys.length !== 1) {
-      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
+      throw new Error(`Invalid key: ${JSON.stringify(key2)}`);
     }
-    return { key: keys[0], def: key[keys[0]] };
+    return { key: keys[0], def: key2[keys[0]] };
   }
-  return { key, def };
+  return { key: key2, def };
 }
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -619,8 +632,8 @@ var MutableURL = class _MutableURL extends URL {
   toString() {
     let search = "";
     if (this._sysURL.searchParams.size) {
-      for (const [key, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-        search += `${!search.length ? "?" : "&"}${key}=${encodeURIComponent(value)}`;
+      for (const [key2, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+        search += `${!search.length ? "?" : "&"}${key2}=${encodeURIComponent(value)}`;
       }
     }
     let hostpart = "";
@@ -655,11 +668,11 @@ function from(fac, strURLUri, defaultProtocol) {
       throw new Error(`Invalid argument: ${typeof strURLUri}`);
   }
 }
-function getParamResult(key, val, msgFn = (key2) => {
-  return `missing parameter: ${key2}`;
+function getParamResult(key2, val, msgFn = (key3) => {
+  return `missing parameter: ${key3}`;
 }) {
   if (val === void 0) {
-    return Result.Err(msgFn(key));
+    return Result.Err(msgFn(key2));
   }
   return Result.Ok(val);
 }
@@ -667,9 +680,15 @@ function getParamsResult(keys, getParam) {
   const keyDef = keys.flat().reduce(
     (acc, i) => {
       if (typeof i === "string") {
-        acc.push({ key: i });
+        acc.push({ key: i, def: void 0, isOptional: false });
       } else if (typeof i === "object") {
-        acc.push(...Object.keys(i).map((k) => ({ key: k, def: typeof i[k] === "string" ? i[k] : void 0 })));
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : void 0,
+            isOptional: i[k] instanceof _OPTIONAL
+          }))
+        );
       }
       return acc;
     },
@@ -687,7 +706,9 @@ function getParamsResult(keys, getParam) {
       if (typeof kd.def === "string") {
         result[kd.key] = kd.def;
       } else {
-        errors.push(kd.key);
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
       }
     } else {
       result[kd.key] = val;
@@ -751,47 +772,47 @@ var BuildURI = class _BuildURI {
     const pathname = "./" + appendUrl.pathname;
     const basePath = this._url.pathname;
     this.pathname(relativePath(basePath, pathname));
-    for (const [key, value] of appendUrl.getParams) {
-      this.setParam(key, value);
+    for (const [key2, value] of appendUrl.getParams) {
+      this.setParam(key2, value);
     }
     return this;
   }
   cleanParams() {
-    for (const key of Array.from(this._url.searchParams.keys())) {
-      this._url.searchParams.delete(key);
+    for (const key2 of Array.from(this._url.searchParams.keys())) {
+      this._url.searchParams.delete(key2);
     }
     return this;
   }
-  delParam(key) {
-    this._url.searchParams.delete(key);
+  delParam(key2) {
+    this._url.searchParams.delete(key2);
     return this;
   }
-  defParam(key, str) {
-    if (!this._url.searchParams.has(key)) {
-      this._url.searchParams.set(key, str);
+  defParam(key2, str) {
+    if (!this._url.searchParams.has(key2)) {
+      this._url.searchParams.set(key2, str);
     }
     return this;
   }
-  setParam(key, str) {
-    this._url.searchParams.set(key, str);
+  setParam(key2, str) {
+    this._url.searchParams.set(key2, str);
     return this;
   }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
+  hasParam(key2) {
+    return this._url.searchParams.has(key2);
   }
   get getParams() {
     return this._url.searchParams.entries();
   }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
+  getParam(key2, def) {
+    const { key: k, def: d } = coerceKey(key2, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
+  getParamResult(key2, msgFn) {
+    return getParamResult(key2, this.getParam(key2), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -834,8 +855,8 @@ var URI = class _URI {
     if (!(fPath.length === 0 || fPath === "/" || fPath === "./")) {
       intoUrl.pathname(fromUrl.pathname);
     }
-    for (const [key, value] of fromUrl.getParams) {
-      intoUrl.setParam(key, value);
+    for (const [key2, value] of fromUrl.getParams) {
+      intoUrl.setParam(key2, value);
     }
     return intoUrl.URI();
   }
@@ -888,19 +909,19 @@ var URI = class _URI {
   get getParams() {
     return this._url.searchParams.entries();
   }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
+  hasParam(key2) {
+    return this._url.searchParams.has(key2);
   }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
+  getParam(key2, def) {
+    const { key: k, def: d } = coerceKey(key2, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
+  getParamResult(key2, msgFn) {
+    return getParamResult(key2, this.getParam(key2), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -1272,9 +1293,9 @@ var LoggerImpl = class _LoggerImpl {
     this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
-  Module(key) {
-    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
-    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+  Module(key2) {
+    this._attributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
@@ -1315,10 +1336,10 @@ var LoggerImpl = class _LoggerImpl {
   }
   Err(err) {
     var _a;
-    let key = "error";
+    let key2 = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        key = "noerror";
+        key2 = "noerror";
         err = err.Ok();
       } else {
         err = err.Err();
@@ -1326,12 +1347,12 @@ var LoggerImpl = class _LoggerImpl {
     }
     if (err instanceof Error) {
       if (err.cause) {
-        this.coerceKey(key, {
+        this.coerceKey(key2, {
           message: err.message,
           cause: err.cause
         });
       } else {
-        this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
+        this._attributes[key2] = logValue(err.message, toLogValueCtx(this.levelHandler));
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
@@ -1340,7 +1361,7 @@ var LoggerImpl = class _LoggerImpl {
         );
       }
     } else {
-      this.Any(key, err);
+      this.Any(key2, err);
     }
     return this;
   }
@@ -1348,22 +1369,22 @@ var LoggerImpl = class _LoggerImpl {
     this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Ref(key, action) {
+  Ref(key2, action) {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action, toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(action, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
-  Bool(key, value) {
-    this.coerceKey(key, !!value);
+  Bool(key2, value) {
+    this.coerceKey(key2, !!value);
     return this;
   }
   Http(...mix) {
-    const key = mix.find((x) => typeof x === "string");
+    const key2 = mix.find((x) => typeof x === "string");
     mix = mix.filter((x) => typeof x !== "string");
     const resErrors = mix.filter((x) => Result.Is(x) && x.isErr());
     if (resErrors.length) {
@@ -1383,72 +1404,72 @@ var LoggerImpl = class _LoggerImpl {
       reqAndOrres = req;
     }
     if (reqAndOrres) {
-      this.Any(key || "Http", reqAndOrres);
+      this.Any(key2 || "Http", reqAndOrres);
     }
     return this;
   }
   Pair(x) {
-    for (const key of Object.keys(x)) {
-      const value = x[key];
+    for (const key2 of Object.keys(x)) {
+      const value = x[key2];
       if (value instanceof LogValue) {
-        this._attributes[key] = value;
+        this._attributes[key2] = value;
         continue;
       }
       if (Result.Is(value)) {
-        this.Result(key, value);
+        this.Result(key2, value);
         continue;
       }
-      this.Any(key, value);
+      this.Any(key2, value);
     }
     return this;
   }
-  Result(key, res) {
+  Result(key2, res) {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
-  Len(value, key = "len") {
-    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
+  Len(value, key2 = "len") {
+    this._attributes[key2] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Hash(value, key = "hash") {
-    this._attributes[key] = asyncLogValue(
+  Hash(value, key2 = "hash") {
+    this._attributes[key2] = asyncLogValue(
       async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`
     );
     return this;
   }
-  Url(url, key = "url") {
-    this.Ref(key, () => URI.from(url).toString());
+  Url(url, key2 = "url") {
+    this.Ref(key2, () => URI.from(url).toString());
     return this;
   }
-  coerceKey(key, value) {
-    if (typeof key === "string") {
-      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
+  coerceKey(key2, value) {
+    if (typeof key2 === "string") {
+      this._attributes[key2] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
-      this.Pair(key);
+      this.Pair(key2);
     }
   }
-  Str(key, value) {
-    this.coerceKey(key, value);
+  Str(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Any(key, value) {
-    this.coerceKey(key, value);
+  Any(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Dur(key, nsec) {
-    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
+  Dur(key2, nsec) {
+    this._attributes[key2] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Uint64(key, value) {
-    this.coerceKey(key, value);
+  Uint64(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Int(key, value) {
-    return this.Uint64(key, value);
+  Int(key2, value) {
+    return this.Uint64(key2, value);
   }
   async Flush() {
     return new Promise((resolve) => {
@@ -1471,8 +1492,8 @@ var LoggerImpl = class _LoggerImpl {
   }
   _resetAttributes(fn) {
     const ret = fn();
-    Object.keys(this._attributes).forEach((key) => {
-      delete this._attributes[key];
+    Object.keys(this._attributes).forEach((key2) => {
+      delete this._attributes[key2];
     });
     Object.assign(this._attributes, this._withAttributes);
     return ret;
@@ -1539,8 +1560,8 @@ var WithLoggerBuilder = class {
     this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
-  Module(key) {
-    this._li.Module(key);
+  Module(key2) {
+    this._li.Module(key2);
     return this;
   }
   SetDebug(...modules) {
@@ -1555,36 +1576,36 @@ var WithLoggerBuilder = class {
     this._li.Pair(x);
     return this;
   }
-  Str(key, value) {
-    this._li.Str(key, value);
+  Str(key2, value) {
+    this._li.Str(key2, value);
     return this;
   }
-  Len(value, key) {
-    this._li.Len(value, key);
+  Len(value, key2) {
+    this._li.Len(value, key2);
     return this;
   }
-  Hash(value, key) {
-    this._li.Hash(value, key);
+  Hash(value, key2) {
+    this._li.Hash(value, key2);
     return this;
   }
-  Ref(key, action) {
-    this._li.Ref(key, action);
+  Ref(key2, action) {
+    this._li.Ref(key2, action);
     return this;
   }
-  Bool(key, value) {
-    this._li.Bool(key, value);
+  Bool(key2, value) {
+    this._li.Bool(key2, value);
     return this;
   }
-  Result(key, res) {
-    this._li.Result(key, res);
+  Result(key2, res) {
+    this._li.Result(key2, res);
     return this;
   }
-  Url(url, key) {
-    this._li.Url(url, key);
+  Url(url, key2) {
+    this._li.Url(url, key2);
     return this;
   }
-  Int(key, value) {
-    this._li.Int(key, value);
+  Int(key2, value) {
+    this._li.Int(key2, value);
     return this;
   }
   Log() {
@@ -1619,16 +1640,16 @@ var WithLoggerBuilder = class {
     this._li.Timestamp();
     return this;
   }
-  Any(key, value) {
-    this._li.Any(key, value);
+  Any(key2, value) {
+    this._li.Any(key2, value);
     return this;
   }
-  Dur(key, nsec) {
-    this._li.Dur(key, nsec);
+  Dur(key2, nsec) {
+    this._li.Dur(key2, nsec);
     return this;
   }
-  Uint64(key, value) {
-    this._li.Uint64(key, value);
+  Uint64(key2, value) {
+    this._li.Uint64(key2, value);
     return this;
   }
 };
@@ -1767,8 +1788,8 @@ var Metrics = class {
   }
   toJSON() {
     const obj = {};
-    for (const [key, value] of this.map) {
-      obj[key] = value.value;
+    for (const [key2, value] of this.map) {
+      obj[key2] = value.value;
     }
     return obj;
   }
@@ -1941,15 +1962,15 @@ var HeadersImpl = class extends Headers {
   values() {
     return this._headers.values();
   }
-  append(key, value) {
-    const values = this._headers.get(key);
+  append(key2, value) {
+    const values = this._headers.get(key2);
     if (typeof value === "undefined") {
       value = "";
     }
     if (Array.isArray(value)) {
-      this._headers.set(key, [values, ...value].filter((i) => i).join(", "));
+      this._headers.set(key2, [values, ...value].filter((i) => i).join(", "));
     } else {
-      this._headers.set(key, [values, value].filter((i) => i).join(", "));
+      this._headers.set(key2, [values, value].filter((i) => i).join(", "));
     }
     return this;
   }
@@ -1992,38 +2013,38 @@ var HttpHeader = class _HttpHeader {
   }
   _asStringString() {
     const ret = /* @__PURE__ */ new Map();
-    for (const [key, values] of this._headers) {
-      ret.set(key, values.join(", "));
+    for (const [key2, values] of this._headers) {
+      ret.set(key2, values.join(", "));
     }
     return ret;
   }
-  _key(key) {
-    return key.toLowerCase();
+  _key(key2) {
+    return key2.toLowerCase();
   }
-  Values(key) {
-    const values = this._headers.get(this._key(key));
+  Values(key2) {
+    const values = this._headers.get(this._key(key2));
     return values || [];
   }
-  Get(key) {
-    const values = this._headers.get(this._key(key));
+  Get(key2) {
+    const values = this._headers.get(this._key(key2));
     if (values === void 0 || values.length === 0) {
       return void 0;
     }
     return values[0];
   }
-  Set(key, valueOr) {
+  Set(key2, valueOr) {
     const value = Array.isArray(valueOr) ? valueOr : [valueOr];
-    this._headers.set(this._key(key), value);
+    this._headers.set(this._key(key2), value);
     return this;
   }
-  Add(key, value) {
+  Add(key2, value) {
     if (typeof value === "undefined") {
       return this;
     }
     const vs = Array.isArray(value) ? value : [value];
-    const values = this._headers.get(this._key(key));
+    const values = this._headers.get(this._key(key2));
     if (values === void 0) {
-      this._headers.set(this._key(key), vs);
+      this._headers.set(this._key(key2), vs);
     } else {
       values.push(...vs);
     }
@@ -2041,29 +2062,29 @@ var HttpHeader = class _HttpHeader {
   }
   Clone() {
     const clone = new _HttpHeader();
-    for (const [key, values] of this._headers.entries()) {
-      clone._headers.set(key, values.slice());
+    for (const [key2, values] of this._headers.entries()) {
+      clone._headers.set(key2, values.slice());
     }
     return clone;
   }
   AsRecordStringStringArray() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = [...values];
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = [...values];
     }
     return obj;
   }
   AsRecordStringString() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = values.join(", ");
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = values.join(", ");
     }
     return obj;
   }
   AsHeaderInit() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = values[0];
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = values[0];
     }
     return obj;
   }
@@ -2073,8 +2094,8 @@ var HttpHeader = class _HttpHeader {
   Merge(other) {
     const ret = this.Clone();
     if (other) {
-      for (const [key, values] of other.Items()) {
-        ret.Add(key, values);
+      for (const [key2, values] of other.Items()) {
+        ret.Add(key2, values);
       }
     }
     return ret;
@@ -2109,7 +2130,6 @@ export {
   MutableURL,
   None,
   Option,
-  REQUIRED,
   RandomMode,
   RandomService,
   ResolveOnce,
@@ -2139,6 +2159,7 @@ export {
   exception2Result,
   hasHostPartProtocols,
   isURL,
+  key,
   logValue,
   runtimeFn,
   toCryptoRuntime,