@adviser/cement 0.2.28 → 0.2.29

package/src/logger.ts

@@ -0,0 +1,208 @@
+import { bin2string } from "./bin2text.js";
+import { Result } from "./result.js";
+import { TxtEnDecoder } from "./txt-en-decoder.js";
+import { CoerceURI } from "./uri.js";
+
+export enum Level {
+  WARN = "warn",
+  DEBUG = "debug",
+  INFO = "info",
+  ERROR = "error",
+}
+
+export type Serialized = string | number | boolean;
+export type FnSerialized = () => Serialized | Serialized[];
+
+export class LogValue {
+  constructor(readonly fn: FnSerialized) {}
+  value(): Serialized | Serialized[] {
+    return this.fn();
+  }
+  toJSON(): Serialized | Serialized[] {
+    return this.value();
+  }
+}
+
+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;
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+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 {
+  switch (typeof val) {
+    case "function":
+      return new LogValue(val);
+    case "string": {
+      try {
+        const ret = JSON.parse(val);
+        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 new LogValue(() => val.toString());
+    }
+    case "number":
+      return new LogValue(() => val);
+    case "boolean":
+      return new LogValue(() => val);
+    case "object": {
+      if (ArrayBuffer.isView(val)) {
+        return logValue(bin2string(val, 512));
+      }
+      if (Array.isArray(val)) {
+        return new LogValue(() => val.map((v) => logValue(v).value() as Serialized));
+      }
+      if (val === null) {
+        return new LogValue(() => "null");
+      }
+      // Duplicate reference found, discard key
+      if (state.has(val)) {
+        return new LogValue(() => "...");
+      }
+      state.add(val);
+
+      const res: Record<string, LogValue> = {};
+      const typedVal = val as unknown as Record<string, LogValueArg>;
+      for (const key in typedVal) {
+        const element = typedVal[key];
+        if (element instanceof LogValue) {
+          res[key] = element;
+        } else {
+          res[key] = logValue(element, state);
+        }
+      }
+      // ugly as hell cast but how declare a self-referencing type?
+      return new LogValue(() => res as unknown as Serialized);
+    }
+    default:
+      if (!val) {
+        return new LogValue(() => "--Falsy--");
+      }
+      throw new Error(`Invalid type:${typeof val}`);
+  }
+}
+
+export interface Sized {
+  size: number;
+}
+export interface Lengthed {
+  length: number;
+}
+export type SizeOrLength = Sized | Lengthed;
+
+export interface LogFormatter {
+  format(attr: LogSerializable): Uint8Array;
+}
+
+export interface LevelHandler {
+  enableLevel(level: Level, ...modules: string[]): void;
+  disableLevel(level: Level, ...modules: string[]): void;
+  setExposeStack(enable?: boolean): void;
+  isStackExposed: boolean;
+  setDebug(...modules: (string | string[])[]): void;
+  isEnabled(ilevel: unknown, module: unknown): boolean;
+}
+
+export interface LoggerInterface<R> {
+  TxtEnDe(): TxtEnDecoder;
+  Module(key: string): R;
+  // if modules is empty, set for all Levels
+  EnableLevel(level: Level, ...modules: string[]): R;
+  DisableLevel(level: Level, ...modules: string[]): R;
+
+  Attributes(): Record<string, unknown>;
+
+  SetDebug(...modules: (string | string[])[]): R;
+  SetExposeStack(enable?: boolean): R;
+  SetFormatter(fmt: LogFormatter): R;
+
+  Ref(key: string, action: { toString: () => string } | FnSerialized): R;
+  Result<T>(key: string, res: Result<T>): R;
+  // default key url
+  Url(url: CoerceURI, key?: string): R;
+  // len
+  Len(value: unknown, key?: string): R;
+
+  Hash(value: unknown, key?: string): R;
+
+  Str(key: string, value?: string): 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
+  Info(): R;
+  Timestamp(): R;
+  Any(key: string, value: unknown): 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 {
+  return (
+    typeof obj === "object" &&
+    [
+      "Module",
+      "EnableLevel",
+      "DisableLevel",
+      "SetDebug",
+      "Str",
+      "Error",
+      "Warn",
+      "Debug",
+      "Log",
+      "WithLevel",
+      "Err",
+      "Info",
+      "Timestamp",
+      "Any",
+      "Dur",
+      "Uint64",
+    ]
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map((fn) => typeof (obj as any)[fn] === "function")
+      .reduce((a, b) => a && b, true)
+  );
+}
+
+export interface WithLogger extends LoggerInterface<WithLogger> {
+  Logger(): Logger;
+}
+
+export interface AsError {
+  AsError(): Error;
+}
+
+export interface Logger extends LoggerInterface<Logger> {
+  With(): WithLogger;
+
+  Msg(...args: string[]): AsError;
+  Flush(): Promise<void>;
+}

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

@@ -0,0 +1,92 @@
+import { FileService, NamedWritableStream } from "../file-service.js";
+import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import * as path from "node:path";
+
+const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
+  cwd(): string;
+  readFile(fname: string): Promise<Uint8Array>;
+  mkdir(base: string, options: { recursive: boolean }): Promise<void>;
+  open(fname: string, options: { write: boolean; create: boolean; truncate: boolean }): Promise<WritableStream>;
+};
+
+export class DenoFileService implements FileService {
+  readonly baseDir: string;
+  readonly txtEnde: TxtEnDecoder;
+  constructor(baseDir: string = Deno.cwd(), txtEnde: TxtEnDecoder = Utf8EnDecoderSingleton()) {
+    this.baseDir = this.abs(baseDir);
+    this.txtEnde = txtEnde;
+  }
+
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+
+  async readFileString(fname: string): Promise<string> {
+    return this.txtEnde.decode(await Deno.readFile(fname));
+  }
+
+  dirname(fname: string): string {
+    return path.dirname(fname);
+  }
+  basename(fname: string): string {
+    return path.basename(fname);
+  }
+
+  join(...paths: string[]): string {
+    return path.join(...paths);
+  }
+
+  relative(from: string, to?: string): string {
+    if (to === undefined) {
+      to = from;
+      from = Deno.cwd();
+    }
+    const ret = path.relative(from, to);
+    // console.log('relative:'+ from + " -> " + to +   "= " + ret);
+    return ret;
+  }
+
+  abs(fname: string): string {
+    if (path.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = Deno.cwd();
+      return path.resolve(cwd, fname);
+    }
+  }
+
+  isAbsolute(fname: string): boolean {
+    return path.isAbsolute(fname);
+  }
+
+  async writeFileString(fname: string, content: string, ende = Utf8EnDecoderSingleton()): Promise<void> {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+
+  async create(fname: string): Promise<NamedWritableStream> {
+    let oName = fname;
+    if (!path.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+
+    const base = path.dirname(oName);
+    await Deno.mkdir(base, { recursive: true });
+    const out = await Deno.open(oName, {
+      write: true,
+      create: true,
+      truncate: true,
+    });
+    return {
+      name: oName,
+      stream: out,
+    };
+  }
+}

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

@@ -0,0 +1,133 @@
+import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import {
+  BaseSysAbstraction,
+  ExitHandler,
+  ExitService,
+  WrapperSysAbstraction,
+  WrapperSysAbstractionParams,
+} from "../base-sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import * as process from "node:process";
+import { DenoFileService } from "./deno-file-service.js";
+
+const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
+  addSignalListener(sig: string, hdl: () => void): void;
+  exit(code?: number): void;
+};
+
+export class DenoExitServiceImpl implements ExitService {
+  constructor() {
+    globalThis.addEventListener("unhandledrejection", (e) => {
+      e.preventDefault();
+      this.exit(19);
+    });
+    globalThis.addEventListener("error", () => {
+      this.exit(19);
+    });
+    globalThis.addEventListener("uncaughtException", () => {
+      this.exit(19);
+    });
+
+    // process.on("close", () => {
+    //   this.exit(0);
+    // });
+    globalThis.addEventListener("unload", () => {
+      this.exit(0);
+      // console.log('goodbye!');
+    });
+
+    // process.on("exit", () => {
+    // });
+    Deno.addSignalListener("SIGQUIT", () => {
+      this.exit(3);
+    });
+    Deno.addSignalListener("SIGINT", () => {
+      this.exit(2);
+    });
+    Deno.addSignalListener("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  _exitHandlers: ExitHandler[] = [];
+  injectExitHandlers(hdls: ExitHandler[]): void {
+    // console.log("ExitService: injecting exit handlers", hdls)
+    this._exitHandlers = hdls;
+  }
+  invoked = false;
+  readonly _handleExit = async (): Promise<void> => {
+    if (this.invoked) {
+      // console.error("ExitService: already invoked");
+      return;
+    }
+    this.invoked = true;
+    for (const h of this._exitHandlers) {
+      try {
+        // console.log(`ExitService: calling handler ${h.id}`)
+        const ret = h.hdl();
+        // console.log(`ExitService: called handler ${h.id}`, ret)
+        if (typeof (ret as Promise<void>).then === "function") {
+          await ret;
+        }
+      } finally {
+        // ignore
+      }
+    }
+  };
+
+  exit(code: number): void {
+    // console.log("ExitService: exit called", code)
+    this._handleExit()
+      .then(() => {
+        Deno.exit(code);
+      })
+      .catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error("ExitService: failed to handle exit", err);
+        Deno.exit(code);
+      });
+  }
+}
+
+export class DenoSystemService implements SystemService {
+  static readonly _exitHandlers: ExitHandler[] = [];
+  readonly _exitService: ExitService = new DenoExitServiceImpl();
+  constructor() {
+    this._exitService.injectExitHandlers(DenoSystemService._exitHandlers);
+  }
+
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return process.argv;
+  }
+
+  OnExit(hdl: VoidFunc): VoidFunc {
+    const id = crypto.randomUUID();
+    DenoSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = DenoSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        DenoSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+
+  Exit(code: number): void {
+    this._exitService.exit(code);
+  }
+}
+
+let my: BaseSysAbstraction | undefined = undefined;
+export function DenoSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
+      FileSystem: new DenoFileService(),
+      SystemService: new DenoSystemService(),
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}

package/src/node/index.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,45 @@
+import { NamedWritableStream } from "../file-service.js";
+import { NodeFileService } from "./node-file-service.js";
+
+export interface FileCollector {
+  readonly name: string;
+  content: string;
+}
+
+export class MockFileService extends NodeFileService {
+  readonly files = {} as Record<string, FileCollector>;
+
+  // override abs(fname: string): string {
+  //   return this.join("/mock/", fname);
+  // }
+
+  override async create(fname: string): Promise<NamedWritableStream> {
+    let oName = fname;
+    if (!this.isAbsolute(fname)) {
+      oName = await this.abs(fname);
+    }
+
+    const fc = {
+      name: oName,
+      content: "",
+    };
+    this.files[oName] = fc;
+    this.files[fname] = fc;
+    const decoder = new TextDecoder();
+
+    return {
+      name: oName,
+      stream: new WritableStream<Uint8Array>({
+        write(chunk): void {
+          fc.content = fc.content + decoder.decode(chunk);
+        },
+        close(): void {
+          // do nothing
+        },
+        abort(): void {
+          throw new Error("not implemented");
+        },
+      }),
+    };
+  }
+}

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

@@ -0,0 +1,91 @@
+import path from "node:path";
+import fs from "node:fs";
+import process from "node:process";
+import { FileService, NamedWritableStream } from "../file-service.js";
+import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class NodeFileService implements FileService {
+  readonly baseDir: string;
+  constructor(baseDir: string = process.cwd()) {
+    this.baseDir = this.abs(baseDir);
+  }
+
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+
+  readFileString(fname: string): Promise<string> {
+    return fs.promises.readFile(fname, { encoding: "utf-8" });
+  }
+
+  dirname(fname: string): string {
+    return path.dirname(fname);
+  }
+  basename(fname: string): string {
+    return path.basename(fname);
+  }
+
+  join(...paths: string[]): string {
+    return path.join(...paths);
+  }
+
+  relative(from: string, to?: string): string {
+    if (to === undefined) {
+      to = from;
+      from = process.cwd();
+    }
+    const ret = path.relative(from, to);
+    // console.log('relative:'+ from + " -> " + to +   "= " + ret);
+    return ret;
+  }
+
+  abs(fname: string): string {
+    if (path.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = process.cwd();
+      return path.resolve(cwd, fname);
+    }
+  }
+
+  isAbsolute(fname: string): boolean {
+    return path.isAbsolute(fname);
+  }
+
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = Utf8EnDecoderSingleton()): Promise<void> {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+
+  async create(fname: string): Promise<NamedWritableStream> {
+    let oName = fname;
+    if (!path.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+
+    const base = path.dirname(oName);
+    await fs.promises.mkdir(base, { recursive: true });
+    const out = fs.createWriteStream(oName);
+    return {
+      name: oName,
+      stream: new WritableStream<Uint8Array>({
+        write(chunk): void {
+          out.write(chunk);
+        },
+        close(): void {
+          out.close();
+        },
+        abort(): void {
+          throw new Error("not implemented");
+        },
+      }),
+    };
+  }
+}

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

@@ -0,0 +1,121 @@
+import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import {
+  BaseSysAbstraction,
+  ExitHandler,
+  ExitService,
+  WrapperSysAbstraction,
+  WrapperSysAbstractionParams,
+} from "../base-sys-abstraction.js";
+import { NodeFileService } from "./node-file-service.js";
+import { Env, envFactory } from "../sys-env.js";
+import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import process from "node:process";
+
+export class NodeExitServiceImpl implements ExitService {
+  constructor() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    process.on("unhandledRejection", (reason: string, p: Promise<unknown>) => {
+      this.exit(19);
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    process.on("uncaughtException", (error: Error) => {
+      this.exit(18);
+    });
+    process.on("close", () => {
+      this.exit(0);
+    });
+    process.on("exit", () => {
+      this.exit(0);
+    });
+    process.on("SIGQUIT", () => {
+      this.exit(3);
+    });
+    process.on("SIGINT", () => {
+      this.exit(2);
+    });
+    process.on("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  _exitHandlers: ExitHandler[] = [];
+  injectExitHandlers(hdls: ExitHandler[]): void {
+    // console.log("ExitService: injecting exit handlers", hdls)
+    this._exitHandlers = hdls;
+  }
+  invoked = false;
+  readonly _handleExit = async (): Promise<void> => {
+    if (this.invoked) {
+      // console.error("ExitService: already invoked");
+      return;
+    }
+    this.invoked = true;
+    for (const h of this._exitHandlers) {
+      try {
+        // console.log(`ExitService: calling handler ${h.id}`)
+        const ret = h.hdl();
+        // console.log(`ExitService: called handler ${h.id}`, ret)
+        if (typeof (ret as Promise<void>).then === "function") {
+          await ret;
+        }
+      } finally {
+        // ignore
+      }
+    }
+  };
+
+  exit(code: number): void {
+    // console.log("ExitService: exit called", code)
+    this._handleExit()
+      .then(() => {
+        process.exit(code);
+      })
+      .catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error("ExitService: failed to handle exit", err);
+        process.exit(code);
+      });
+  }
+}
+
+export class NodeSystemService implements SystemService {
+  static readonly _exitHandlers: ExitHandler[] = [];
+  readonly _exitService: ExitService = new NodeExitServiceImpl();
+  constructor() {
+    this._exitService.injectExitHandlers(NodeSystemService._exitHandlers);
+  }
+
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return process.argv;
+  }
+
+  OnExit(hdl: VoidFunc): VoidFunc {
+    const id = crypto.randomUUID();
+    NodeSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = NodeSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        NodeSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+
+  Exit(code: number): void {
+    this._exitService.exit(code);
+  }
+}
+
+let my: BaseSysAbstraction | undefined = undefined;
+export function NodeSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
+      FileSystem: new NodeFileService(),
+      SystemService: new NodeSystemService(),
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}