@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

package/src/logger.ts

@@ -1,14 +1,20 @@
+// / <reference lib="dom" />
+import { isPromise } from "./is-promise.js";
 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";
+import { CoerceURI, MutableURL } from "./uri.js";
+import { isJSON } from "./is-json.js";
 
-export enum Level {
-  WARN = "warn",
-  DEBUG = "debug",
-  INFO = "info",
-  ERROR = "error",
-}
+export const Level = {
+  WARN: "warn",
+  DEBUG: "debug",
+  INFO: "info",
+  ERROR: "error",
+};
+
+export type Level = (typeof Level)[keyof typeof Level];
 
 export type Serialized = string | number | boolean;
 export type FnSerialized = () => Serialized | Serialized[];
@@ -16,7 +22,12 @@ export type FnSerialized = () => Serialized | Serialized[];
 export class LogValue {
   constructor(readonly fn: FnSerialized) {}
   value(): Serialized | Serialized[] {
-    return this.fn();
+    try {
+      // console.log("LogValue.value", this.fn.toString());
+      return this.fn();
+    } catch (e) {
+      return `LogValue:${(e as Error).message}`;
+    }
   }
   toJSON(): Serialized | Serialized[] {
     return this.value();
@@ -25,43 +36,63 @@ export class LogValue {
 
 export type LogSerializable = Record<string, LogValue | Promise<LogValue>>;
 
-export function removeSelfRef(lineEnd?: string): (key: unknown, val: unknown) => unknown {
-  const cache = new Set();
-  return function (key: unknown, value: unknown) {
-    if (typeof value === "object" && value !== null) {
-      // Duplicate reference found, discard key
-      if (cache.has(value)) return "...";
-      cache.add(value);
-    }
-    return lineEnd ? value + lineEnd : value;
-  };
-}
+// export function sanitizeSerialize(lineEnd?: string): (key: unknown, val: unknown) => unknown {
+//   const cache = new Set();
+//   return function (this: unknown, key: unknown, value: unknown) {
+//     if (typeof value === "object" && value !== null) {
+//       // Duplicate reference found, discard key
+//       if (cache.has(value)) return "...";
+//       cache.add(value);
+//     }
+//     return lineEnd ? value + lineEnd : value;
+//   };
+// }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function asyncLogValue(val: () => Promise<Serialized>): Promise<LogValue> {
+export function asyncLogValue(_val: () => Promise<Serialized>): Promise<LogValue> {
   // return Promise.resolve(logValue(val));
   throw new Error("Not implemented");
 }
 
 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);
     case "string": {
-      try {
-        const ret = JSON.parse(val);
+      const resIsJson = isJSON<LogValueArg>(val);
+      if (resIsJson.isJSON) {
+        const ret = resIsJson.parsed;
         if (typeof ret === "object" && ret !== null) {
-          return logValue(ret, state);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      } catch (e) {
-        if (val.match(/[\n\r]/)) {
-          const lines = val.trimEnd().split(/[\n\r]/);
-          return new LogValue(() => lines);
+          return logValueInternal(ret, ctx);
         }
       }
+      const resIsURI = MutableURL.from(val);
+      if (resIsURI.isOk()) {
+        return new LogValue(() => resIsURI.Ok().toString());
+      }
+      if (val.match(/[\n\r]/)) {
+        const lines = val.split(/[\n\r]+/).map((v) => v.trim());
+        return new LogValue(() => lines);
+      }
       return new LogValue(() => val.toString());
     }
     case "number":
@@ -69,29 +100,71 @@ export function logValue(val: LogValueArg, state: Set<unknown> = new Set<unknown
     case "boolean":
       return new LogValue(() => val);
     case "object": {
+      if (val === null) {
+        return new LogValue(() => "null");
+      }
       if (ArrayBuffer.isView(val)) {
-        return logValue(bin2string(val, 512));
+        try {
+          // should be injected
+          const decoder = new TextDecoder();
+          const asStr = decoder.decode(val);
+          const resIsJson = isJSON<LogValueArg>(asStr);
+          if (resIsJson.isJSON) {
+            const obj = JSON.parse(asStr) as LogValueArg;
+            return logValueInternal(obj, ctx);
+          }
+        } catch (e) {
+          // noop, we will return the stringified value
+        }
+        return logValueInternal(bin2string(val, 512), ctx);
       }
       if (Array.isArray(val)) {
-        return new LogValue(() => val.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 === null) {
-        return new LogValue(() => "null");
+      // if (val instanceof Response) {
+      //   // my = my.clone() as unknown as LogValue | Serialized[] | null
+      //   // const rval = my as unknown as Partial<Response>;
+      //   // delete rval.clone
+      //   // delete rval.blob
+      // }
+      if (val instanceof Headers) {
+        const headers: Record<string, string> = {};
+        val.forEach((v, k) => {
+          headers[k] = v;
+        });
+        return new LogValue(() => headers as unknown as Serialized);
+      }
+      if (val instanceof ReadableStream) {
+        return new LogValue(() => ">Stream<");
       }
+      if (isPromise(val)) {
+        return new LogValue(() => ">Promise<");
+      }
+
       // 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());
+      }
 
       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 {
-          res[key] = logValue(element, state);
+          if (typeof element !== "function") {
+            res[key] = logValueInternal(element, ctx);
+          }
         }
       }
       // ugly as hell cast but how declare a self-referencing type?
@@ -121,12 +194,21 @@ 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;
+
+  timerStart(key: string): Date; // now
+  timerEnd(key: string): { now: Date; duration: number }; // returns duration in nanoseconds
+
   setDebug(...modules: (string | string[])[]): void;
   isEnabled(ilevel: unknown, module: unknown): boolean;
 }
 
+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
@@ -136,6 +218,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;
 
@@ -148,21 +232,30 @@ export interface LoggerInterface<R> {
 
   Hash(value: unknown, key?: string): R;
 
-  Str(key: string, value?: string): R;
+  Str<T extends string | Record<string, string>>(key: T, value?: T extends string ? string : undefined): R;
+  Uint64<T extends string | Record<string, number>>(key: T, value?: T extends string ? number : undefined): R;
+  Int<T extends string | Record<string, number>>(key: T, value?: T extends string ? number : undefined): R;
+  Bool<T extends string | Record<string, unknown>>(key: T, value?: T extends string ? unknown : undefined): R;
+  Any<T extends string | Record<string, unknown>>(key: T, value?: T extends string ? unknown : undefined): R;
+
+  // first string is the key
+  // first response is Response
+  // first request is Request
+  Http(...mix: (HttpType | string)[]): R;
+  Pair(x: Record<string, unknown>): R;
+
   Error(): R;
   Warn(): R;
   Debug(): R;
   Log(): R;
   WithLevel(level: Level): R;
 
-  Err(err: unknown | Result<unknown> | Error): R; // could be Error, or something which coerces to string
+  Err<T>(err: T | Result<T> | Error): R; // could be Error, or something which coerces to string
   Info(): R;
   Timestamp(): R;
-  Any(key: string, value: unknown): R;
+  TimerStart(key: string): R;
+  TimerEnd(key: string): R;
   Dur(key: string, nsec: number): R;
-  Uint64(key: string, value: number): R;
-  Int(key: string, value: number): R;
-  Bool(key: string, value: unknown): R;
 }
 
 export function IsLogger(obj: unknown): obj is Logger {
@@ -186,8 +279,7 @@ export function IsLogger(obj: unknown): obj is Logger {
       "Dur",
       "Uint64",
     ]
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .map((fn) => typeof (obj as any)[fn] === "function")
+      .map((fn) => typeof (obj as Record<string, unknown>)[fn] === "function")
       .reduce((a, b) => a && b, true)
   );
 }
@@ -198,6 +290,7 @@ export interface WithLogger extends LoggerInterface<WithLogger> {
 
 export interface AsError {
   AsError(): Error;
+  ResultError<T>(): Result<T>;
 }
 
 export interface Logger extends LoggerInterface<Logger> {

package/src/lru-map-set.ts

@@ -0,0 +1,244 @@
+import { AppContext } from "./app-context.js";
+
+export interface LRUParam {
+  readonly maxEntries: number;
+  readonly maxAge: number; // not implemented
+}
+
+export class LRUSet<T> {
+  private readonly _lruMap: LRUMap<T, T>;
+
+  constructor(param: Partial<LRUParam> = {}) {
+    this._lruMap = new LRUMap<T, T>(param);
+  }
+
+  setParam(param: Partial<LRUParam> = {}): void {
+    this._lruMap.setParam(param);
+  }
+
+  get size(): number {
+    return this._lruMap.size;
+  }
+
+  has(key: T): boolean {
+    return this._lruMap.has(key);
+  }
+
+  add(key: T): void {
+    this._lruMap.set(key, key);
+  }
+
+  delete(key: T): void {
+    this._lruMap.delete(key);
+  }
+
+  clear(): void {
+    this._lruMap.clear();
+  }
+
+  forEach(callbackfn: (value: T, key: T) => void): void {
+    this._lruMap.forEach((value) => callbackfn(value, value));
+  }
+
+  entries(): IterableIterator<[T, T, LRUCtx<T, T>]> {
+    return this._lruMap.entries();
+  }
+}
+
+export interface LRUCtx<T, K> {
+  readonly update: boolean;
+  readonly ref: LRUMap<T, K>;
+  readonly stats: LRUMap<T, K>["stats"];
+  readonly item: LRUItem<K>;
+}
+
+export interface LRUItem<K> {
+  readonly value: K;
+  ctx?: AppContext;
+}
+
+export type LRUMapFn<K, T> = (key: K, value: T, meta: LRUCtx<K, T>) => void;
+export type UnregFn = () => void;
+
+export class LRUMap<T, K> {
+  private _map: Map<T, LRUItem<K>> = new Map<T, LRUItem<K>>();
+  private param: LRUParam;
+
+  readonly stats = {
+    gets: 0,
+    puts: 0,
+    deletes: 0,
+  };
+
+  constructor(c: Partial<LRUParam> = {}) {
+    this.param = {
+      maxEntries: c.maxEntries || 100,
+      maxAge: c.maxAge || 0,
+    };
+  }
+
+  private _onSetFns: Map<string, LRUMapFn<T, K>> = new Map<string, LRUMapFn<T, K>>();
+  onSet(fn: LRUMapFn<T, K>): UnregFn {
+    const id = Math.random().toString(36);
+    this._onSetFns.set(id, fn);
+    return () => {
+      this._onSetFns.delete(id);
+    };
+  }
+  private _onDeleteFns: Map<string, LRUMapFn<T, K>> = new Map<string, LRUMapFn<T, K>>();
+  onDelete(fn: LRUMapFn<T, K>): UnregFn {
+    const id = Math.random().toString(36);
+    this._onDeleteFns.set(id, fn);
+    return () => {
+      this._onDeleteFns.delete(id);
+    };
+  }
+
+  private touch(key: T): LRUItem<K> {
+    if (!this._map.has(key)) {
+      throw new Error(`key not found in cache: ${key as unknown as string}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    const value = this._map.get(key) as LRUItem<K>;
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+
+  setParam(param: Partial<LRUParam> = {}): void {
+    if (typeof param.maxEntries === "number") {
+      (this.param as { maxEntries: number }).maxEntries = param.maxEntries;
+      if (param.maxEntries > 0 && this._map.size > param.maxEntries) {
+        const toDelete: T[] = [];
+        let cacheSize = this._map.size;
+        for (const key of this._map.keys()) {
+          if (cacheSize > param.maxEntries) {
+            toDelete.push(key);
+            cacheSize--;
+          } else {
+            break;
+          }
+        }
+        for (const key of toDelete) {
+          this._map.delete(key);
+        }
+      }
+    }
+  }
+
+  has(key: T): boolean {
+    return this._map.has(key);
+  }
+
+  get size(): number {
+    return this._map.size;
+  }
+
+  async getSet(key: T, createFN: (key: T) => Promise<K>): Promise<K | undefined> {
+    const val = this.get(key);
+    if (val) {
+      return val;
+    } else {
+      const val = await createFN(key);
+      this.set(key, val as K);
+      return val;
+    }
+  }
+
+  get(key: T): K | undefined {
+    return this.getItem(key)?.value;
+  }
+
+  getItem(key: T): LRUItem<K> | undefined {
+    if (this._map.has(key)) {
+      this.stats.gets++;
+      return this.touch(key);
+    }
+    return undefined;
+  }
+
+  private buildItem(item: LRUItem<K> | undefined, value: K): LRUItem<K> {
+    return {
+      ...item,
+      value,
+    };
+  }
+
+  set(key: T, value: K): void {
+    const update = this._map.has(key);
+    let item = this._map.get(key);
+    if (update) {
+      if (item?.value === value) {
+        return;
+      }
+      // simulate touch
+      this._map.delete(key);
+    }
+    item = this.buildItem(item, value);
+    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
+      // delete the least recently accessed
+      // const key = Array.from(this.cache.keys())[0];
+      // this.cache.delete(key) or
+      const v = this._map.keys().next();
+      if (!v.done) {
+        this._map.delete(v.value as T);
+      }
+    }
+    this._map.set(key, item);
+    this.stats.puts++;
+    this._onSetFns.forEach((fn) => fn(key, item?.value, this.buildItemCtx(item, update)));
+  }
+
+  private buildItemCtx(item: LRUItem<K>, update: boolean): LRUCtx<T, K> {
+    return {
+      update,
+      ref: this,
+      stats: this.stats,
+      item,
+    };
+  }
+
+  delete(key: T): void {
+    if (this._map.has(key)) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+      const item = this._map.get(key) as LRUItem<K>;
+      this._onDeleteFns.forEach((fn) => fn(key, item?.value, this.buildItemCtx(item, true)));
+      this._map.delete(key);
+      this.stats.deletes++;
+    }
+  }
+
+  clear(): void {
+    this._map.forEach((value, key) => {
+      const item = this.buildItemCtx(value, true);
+      this._onDeleteFns.forEach((fn) => fn(key, item.item.value, item));
+      this.stats.deletes++;
+    });
+    this._map.clear();
+  }
+
+  forEach(fn: (value: K, key: T, ctx: LRUCtx<T, K>) => void): void {
+    this._map.forEach((v, k) => {
+      fn(v.value, k, this.buildItemCtx(v, false));
+    });
+  }
+
+  *entries(): IterableIterator<[T, K, LRUCtx<T, K>]> {
+    for (const [key, value] of this._map.entries()) {
+      yield [key, value.value, this.buildItemCtx(value, true)];
+    }
+  }
+  // *entries(): IterableIterator<[T, K]> {
+  //   for (const x of this._cache.entries()) {
+  //     yield x;
+  //   }
+  // }
+
+  //   getLeastRecent(): K {
+  //     return Array.from(this.cache)[0];
+  //   }
+
+  //   getMostRecent(): K {
+  //     return Array.from(this.cache)[this.cache.size - 1];
+  //   }
+}

package/src/node/get-iface-adr.ts

@@ -0,0 +1,32 @@
+import { NetworkInterfaceInfo, networkInterfaces } from "node:os";
+
+export function getInterfaceAddresses(): Record<string, NetworkInterfaceInfo[]> {
+  const nets = networkInterfaces();
+  return Array.from(Object.entries(nets))
+    .filter((i) => i[1])
+    .reduce(
+      (acc, [name, nets]) => {
+        if (nets) {
+          // console.log(name, nets);
+          acc[name] = nets; // as NetworkInterfaceInfo[];
+        }
+        return acc;
+      },
+      {} as Record<string, NetworkInterfaceInfo[]>,
+    );
+}
+// for (const name of Object.keys(nets)) {
+//     for (const net of nets[name]) {
+//         // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
+//         // 'IPv4' is in Node <= 17, from 18 it's a number 4 or 6
+//         const familyV4Value = typeof net.family === 'string' ? 'IPv4' : 4
+//         if (net.family === familyV4Value && !net.internal) {
+//             if (!results[name]) {
+//                 results[name] = [];
+//             }
+//             results[name].push(net.address);
+//         }
+//     }
+// }
+
+// console.log(getInterfaceAddresses());

package/src/node/index.ts

@@ -1,4 +1,3 @@
 export * from "./node-file-service.js";
 export * from "./node-sys-abstraction.js";
-export * from "./deno-sys-abstraction.js";
 export * from "./mock-file-service.js";

package/src/node/mock-file-service.ts

@@ -13,10 +13,10 @@ export class MockFileService extends NodeFileService {
   //   return this.join("/mock/", fname);
   // }
 
-  override async create(fname: string): Promise<NamedWritableStream> {
+  override create(fname: string): Promise<NamedWritableStream> {
     let oName = fname;
     if (!this.isAbsolute(fname)) {
-      oName = await this.abs(fname);
+      oName = this.abs(fname);
     }
 
     const fc = {
@@ -27,7 +27,7 @@ export class MockFileService extends NodeFileService {
     this.files[fname] = fc;
     const decoder = new TextDecoder();
 
-    return {
+    return Promise.resolve({
       name: oName,
       stream: new WritableStream<Uint8Array>({
         write(chunk): void {
@@ -40,6 +40,6 @@ export class MockFileService extends NodeFileService {
           throw new Error("not implemented");
         },
       }),
-    };
+    });
   }
 }

package/src/node/node-basic-sys-abstraction.ts

@@ -0,0 +1,59 @@
+import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class NodeRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  readonly _gthis: {
+    process: {
+      argv: string[];
+      stdout: {
+        write(chunk: Uint8Array): void;
+      };
+      stderr: {
+        write(chunk: Uint8Array): void;
+      };
+    };
+  };
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+    this._gthis = globalThis as unknown as NodeRuntimeService["_gthis"];
+  }
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return this._gthis.process.argv;
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return new WritableStream({
+      write: (chunk: Uint8Array): void => {
+        this._gthis.process.stdout.write(chunk);
+      },
+    });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return new WritableStream<Uint8Array>({
+      write: (chunk: Uint8Array): void => {
+        this._gthis.process.stderr.write(chunk);
+      },
+    });
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function NodeBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new NodeRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}