@adviser/cement 0.2.27 → 0.2.29

package/src/result.ts

@@ -0,0 +1,165 @@
+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> {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t) as E);
+    }
+    return new ResultError(t);
+  }
+  static Is<T>(t: unknown): t is Result<T> {
+    if (!t) {
+      return false;
+    }
+    if (t instanceof Result) {
+      return true;
+    }
+    const rt = t as Result<T>;
+    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
+      return true;
+    }
+    return false;
+  }
+
+  isOk(): boolean {
+    return this.is_ok();
+  }
+  isErr(): boolean {
+    return this.is_err();
+  }
+
+  Ok(): T {
+    return this.unwrap();
+  }
+  Err(): E {
+    return this.unwrap_err();
+  }
+
+  abstract is_ok(): boolean;
+  abstract is_err(): boolean;
+  abstract unwrap(): T;
+  abstract unwrap_err(): E;
+}
+
+export class ResultOK<T> extends Result<T, Error> {
+  private _t: T;
+  constructor(t: T) {
+    super();
+    this._t = t;
+  }
+  is_ok(): boolean {
+    return true;
+  }
+  is_err(): boolean {
+    return false;
+  }
+  unwrap_err(): Error {
+    throw new Error("Result is Ok");
+  }
+  unwrap(): T {
+    return this._t;
+  }
+}
+
+export class ResultError<T extends Error> extends Result<never, T> {
+  private _error: T;
+  constructor(t: T) {
+    super();
+    this._error = t;
+  }
+  is_ok(): boolean {
+    return false;
+  }
+  is_err(): boolean {
+    return true;
+  }
+  unwrap(): never {
+    throw new Error(`Result is Err: ${this._error}`);
+  }
+  unwrap_err(): T {
+    return this._error;
+  }
+}
+
+export type WithoutResult<T> = T extends Result<infer U> ? U : T;
+
+// type WithoutPromise<T> = T extends Promise<infer U> ? U : T;
+type WithResult<T> = T extends Promise<infer U> ? Promise<Result<U>> : Result<T>;
+
+export function exception2Result<FN extends () => Promise<T> | T, T>(fn: FN): WithResult<ReturnType<FN>> {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e)) as WithResult<ReturnType<FN>>;
+    }
+    return Result.Ok(res) as WithResult<ReturnType<FN>>;
+  } catch (e) {
+    return Result.Err(e as Error) as WithResult<ReturnType<FN>>;
+  }
+}
+
+/*
+
+type FinalizedResult<T> = {
+  result: T;
+  scopeResult?: Result<void>;
+  finally: () => Promise<void>;
+}
+
+type exection2ResultParam<T> = {
+  init: () => Promise<T>;
+  inScope?: (t: T) => Promise<void>;
+  cleanup: (t: T) => Promise<void>;
+
+}
+
+async function expection2Result<T>({fn, inScope, cleanup}: exection2ResultParam<T>): Promise<Result<FinalizedResult<T>>> {
+  try {
+    const res = await fn();
+    if (inScope) {
+      try {
+        await inScope?.(res)
+      } catch (err) {
+        return Result.Err(err as Error)
+      }
+      await cleanup(res)
+      return Result.Ok({
+        result: res,
+        finally: async () => { }
+      })
+    }
+    return Result.Ok({
+      result: res ,
+      finally: async () => {
+        return cleanup(res)
+      }
+    })
+  } catch (err) {
+    return Result.Err(err as Error)
+  }
+}
+*/
+
+// await expection2Result({
+//   init: openDB,
+//   inScope: (res) => {
+//     res.query()
+//   },
+//   cleanup: async (y) => {
+//     await y.close()
+//  }
+// })
+// async function openDB() {
+//   try {
+//     const opendb = await openDB()
+//     return Result.Ok({
+//       openDB,
+//       finally: async () => {
+//         await opendb.close()
+//     }})
+//   } catch (err) {
+//     return Result.Err(err)
+//   }
+// }
+// }

package/src/runtime.ts

@@ -0,0 +1,36 @@
+export interface Runtime {
+  isNodeIsh: boolean;
+  isBrowser: boolean;
+  isDeno: boolean;
+  isReactNative: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isSet(value: string, ref: any = globalThis): boolean {
+  const [head, ...tail] = value.split(".");
+  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
+    if (tail.length <= 1) {
+      return true;
+    }
+    return isSet(tail.join("."), ref[head]);
+  }
+  return false;
+}
+
+export function runtimeFn(): Runtime {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const gt: any = globalThis;
+  const isReactNative =
+    isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
+  let isNodeIsh = false;
+  if (!isSet("Deno")) {
+    isNodeIsh = isSet("process.versions.node") && !isReactNative;
+  }
+  const isDeno = isSet("Deno");
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
+    isDeno,
+    isReactNative,
+  };
+}

package/src/sys-abstraction.ts

@@ -0,0 +1,53 @@
+import { FileService } from "./file-service.js";
+import { Env } from "./sys-env.js";
+import { Time } from "./time.js";
+
+export enum TimeMode {
+  REAL = "real",
+  CONST = "const",
+  STEP = "step",
+}
+
+export enum RandomMode {
+  CONST = "const",
+  STEP = "step",
+  RANDOM = "random",
+}
+
+export enum IDMode {
+  UUID = "uuid",
+  CONST = "const",
+  STEP = "step",
+}
+
+export function String2TimeMode(s?: string): TimeMode {
+  switch (s?.toLowerCase()) {
+    case "real":
+      return TimeMode.REAL;
+    case "const":
+      return TimeMode.CONST;
+    case "step":
+      return TimeMode.STEP;
+    default:
+      return TimeMode.REAL;
+  }
+}
+
+export type VoidFunc = () => void | Promise<void>;
+
+export interface SystemService {
+  Env(): Env;
+  Args(): string[];
+  OnExit(hdl: VoidFunc): VoidFunc;
+  Exit(code: number): void;
+}
+
+export interface SysAbstraction {
+  Time(): Time;
+  Stdout(): WritableStream<Uint8Array>;
+  Stderr(): WritableStream<Uint8Array>;
+  NextId(): string;
+  Random0ToValue(value: number): number;
+  System(): SystemService;
+  FileSystem(): FileService;
+}

package/src/sys-env.test.ts

@@ -0,0 +1,53 @@
+import { BrowserEnvActions, EnvImpl, envFactory } from "@adviser/cement";
+
+describe("sys_env", () => {
+  let key: string;
+  const envImpl = envFactory();
+  beforeEach(() => {
+    key = `key-${Math.random()}`;
+  });
+  it("actions", () => {
+    expect(envImpl.get(key)).toBeUndefined();
+    envImpl.set(key, "value");
+    expect(envImpl.get(key)).toBe("value");
+    envImpl.set(key);
+    expect(envImpl.get(key)).toBe("value");
+    envImpl.delete(key);
+    expect(envImpl.get(key)).toBeUndefined();
+  });
+  it("preset", () => {
+    const env = new EnvImpl(new BrowserEnvActions({}), {
+      presetEnv: new Map([[key, "value"]]),
+    });
+    expect(env.get(key)).toBe("value");
+    env.delete(key);
+    expect(env.get(key)).toBeUndefined();
+  });
+  it("onSet wild card", () => {
+    const fn = vi.fn();
+    envImpl.onSet(fn);
+    expect(fn).toBeCalledTimes(envImpl.keys().length);
+    expect(fn.mock.calls.map((i) => i[0]).sort()).toEqual(envImpl.keys().sort());
+    expect(fn.mock.calls.map((i) => i[1]).sort()).toEqual(
+      envImpl
+        .keys()
+        .map((i) => envImpl.get(i))
+        .sort(),
+    );
+  });
+  it("onSet filter", () => {
+    const env = new EnvImpl(new BrowserEnvActions({}), {
+      presetEnv: new Map([[key, "value"]]),
+    });
+    const fn = vi.fn();
+    env.onSet(fn, key);
+    expect(fn).toBeCalledTimes(1);
+    expect(fn.mock.calls[0]).toEqual([key, "value"]);
+    env.set(key, "value2");
+    expect(fn).toBeCalledTimes(2);
+    expect(fn.mock.calls[1]).toEqual([key, "value2"]);
+    env.delete(key);
+    expect(fn).toBeCalledTimes(3);
+    expect(fn.mock.calls[2]).toEqual([key, undefined]);
+  });
+});

package/src/sys-env.ts

@@ -0,0 +1,216 @@
+import { ResolveOnce } from "./resolve-once.js";
+
+export interface EnvMap {
+  get(key: string): string | undefined;
+  set(key: string, value?: string): void;
+  delete(key: string): void;
+  keys(): string[];
+}
+export interface EnvActions extends EnvMap {
+  active(): boolean;
+  register(env: Env): Env;
+}
+
+class NodeEnvActions implements EnvActions {
+  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+  constructor(opts: Partial<EnvFactoryOpts>) {
+    // do nothing
+  }
+
+  register(env: Env): Env {
+    return env;
+  }
+
+  active(): boolean {
+    return typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
+  }
+  readonly _env = this.active() ? this.#node.process.env : {};
+  keys(): string[] {
+    return Object.keys(this._env);
+  }
+  get(key: string): string | undefined {
+    return this._env[key];
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key: string): void {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete this._env[key];
+  }
+}
+
+class DenoEnvActions implements EnvActions {
+  readonly #deno = globalThis as unknown as { Deno: { env: Map<string, string> } };
+
+  get _env(): Map<string, string> {
+    return this.#deno.Deno.env;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+  constructor(opts: Partial<EnvFactoryOpts>) {
+    // do nothing
+  }
+
+  register(env: Env): Env {
+    return env;
+  }
+  active(): boolean {
+    return typeof this.#deno === "object" && typeof this.#deno.Deno === "object" && typeof this.#deno.Deno.env === "object";
+  }
+  keys(): string[] {
+    return Array.from(this._env.keys());
+  }
+  get(key: string): string | undefined {
+    return this._env.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this._env.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this._env.delete(key);
+  }
+}
+
+export class BrowserEnvActions implements EnvActions {
+  readonly env: Map<string, string> = new Map<string, string>();
+  readonly opts: Partial<EnvFactoryOpts>;
+  constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  get(key: string): string | undefined {
+    return this.env.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.env.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.env.keys());
+  }
+  active(): boolean {
+    return true; // that should work on every runtime
+  }
+
+  register(env: Env): Env {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis as unknown as Record<symbol, Env>;
+    browser[sym] = env;
+    return env;
+  }
+}
+
+export interface EnvFactoryOpts {
+  readonly symbol: string; // default "CP_ENV" used by BrowserEnvActions
+  readonly presetEnv: Map<string, string>;
+}
+
+type OnSetFn = (key: string, value?: string) => void;
+export interface OnSetItem {
+  readonly filter: Set<string>;
+  readonly fn: OnSetFn;
+}
+
+export interface Env extends EnvMap {
+  onSet(fn: OnSetFn, ...filter: string[]): void;
+}
+
+const _envFactory = new ResolveOnce<Env>();
+export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
+  return _envFactory.once(() => {
+    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.active());
+    if (!found) {
+      throw new Error("SysContainer:envFactory: no env available");
+    }
+    const ret = new EnvImpl(found, opts);
+    found.register(ret);
+    return ret;
+  });
+}
+
+export class EnvImpl implements Env {
+  readonly _map: EnvMap;
+  constructor(map: EnvMap, opts: Partial<EnvFactoryOpts> = {}) {
+    this._map = map;
+    this._updatePresets(opts.presetEnv);
+  }
+  _updatePresets(presetEnv?: Map<string, string>): void {
+    if (!presetEnv) {
+      return;
+    }
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
+    }
+  }
+  _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void {
+    onSet.forEach((item) => {
+      let keys: string[] = [];
+      if (key) {
+        keys = [key];
+      } else {
+        keys = this._map.keys();
+      }
+      keys
+        .filter((k) => {
+          if (item.filter.size === 0) {
+            return true;
+          }
+          if (item.filter.has(k)) {
+            return true;
+          }
+          return false;
+        })
+        .forEach((k) => {
+          let v;
+          if (!key && !value) {
+            // init
+            v = this._map.get(k);
+          } else if (key && !value) {
+            // del
+            v = undefined;
+          } else {
+            // set
+            v = value;
+          }
+          item.fn(k, v);
+        });
+    });
+  }
+  readonly _onSet: OnSetItem[] = [];
+  keys(): string[] {
+    return this._map.keys();
+  }
+  // filter is not set all sets passed
+  onSet(fn: OnSetFn, ...filter: string[]): void {
+    const item: OnSetItem = { filter: new Set(filter), fn };
+    this._onSet.push(item);
+    this._applyOnSet([item]);
+  }
+  get(key: string): string | undefined {
+    return this._map.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (!value) {
+      return;
+    }
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
+  }
+  delete(key: string): void {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
+  }
+}
+
+// export const envImpl = new EnvImpl();

package/src/test/log-write-stream.ts

@@ -0,0 +1,95 @@
+import { FanoutWriteStream } from "../utils/fanout-write-stream.js";
+import { Future } from "../future.js";
+import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
+  private readonly _bufferArr: Uint8Array[];
+
+  constructor(bufferArr: Uint8Array[]) {
+    this._bufferArr = bufferArr;
+  }
+
+  readonly _resolveClosed: Future<undefined> = new Future<undefined>();
+  readonly closed: Promise<undefined> = this._resolveClosed.asPromise();
+  readonly desiredSize: number | null = null;
+  readonly ready: Promise<undefined> = Promise.resolve(undefined);
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason?: any): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  async close(): Promise<void> {
+    await this.closed;
+    return Promise.resolve(undefined);
+  }
+  releaseLock(): void {
+    // do nothing
+  }
+  async write(chunk?: Uint8Array): Promise<void> {
+    if (chunk) {
+      this._bufferArr.push(chunk);
+    }
+    return Promise.resolve(undefined);
+  }
+}
+
+export class LogCollector implements WritableStream<Uint8Array> {
+  readonly locked: boolean = false;
+  private _writer?: FanoutWriteStream;
+  private readonly _pass?: WritableStreamDefaultWriter<Uint8Array>;
+  private readonly _bufferArr: Uint8Array[] = [];
+  private readonly _txtEnDe: TxtEnDecoder;
+
+  constructor(pass?: WritableStreamDefaultWriter<Uint8Array>, txtEnDe?: TxtEnDecoder) {
+    this._pass = pass;
+    this._txtEnDe = txtEnDe || Utf8EnDecoderSingleton();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abort(reason?: Uint8Array): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  async close(): Promise<void> {
+    if (this._writer) {
+      const ret = await this._writer.close();
+      this._writer = undefined;
+      return ret;
+    }
+    return Promise.resolve(undefined);
+  }
+
+  getWriter(): WritableStreamDefaultWriter<Uint8Array> {
+    if (!this._writer) {
+      const dests: WritableStreamDefaultWriter[] = [new LogWriteStream(this._bufferArr)];
+      if (this._pass) {
+        dests.push(this._pass);
+      }
+      this._writer = new FanoutWriteStream(dests);
+    }
+    return this._writer;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Logs(notJsonLine = false): any[] {
+    if (!this._writer) {
+      return [];
+    }
+    const jsonNlStr = this._txtEnDe.decode(
+      new Uint8Array(
+        (function* (res: Uint8Array[]): Generator<number, void, undefined> {
+          for (const x of res) {
+            yield* x;
+          }
+        })(this._bufferArr),
+      ),
+    );
+    if (!notJsonLine) {
+      const splitStr = jsonNlStr.split("\n");
+      const filterStr = splitStr.filter((a) => a.length);
+      const mapStr = filterStr.map((a) => JSON.parse(a));
+      return mapStr;
+    }
+    return jsonNlStr.split("\n").filter((a) => a.length);
+  }
+}

package/src/test/mock-logger.ts

@@ -0,0 +1,40 @@
+import { LevelHandlerImpl } from "../log-level-impl.js";
+import { Logger } from "../logger.js";
+import { LoggerImpl } from "../logger-impl.js";
+import { SysAbstraction } from "../sys-abstraction.js";
+import { LogCollector } from "./log-write-stream.js";
+
+export interface MockLoggerReturn {
+  readonly logger: Logger;
+  readonly logCollector: LogCollector;
+}
+
+export function MockLogger(params?: {
+  readonly sys?: SysAbstraction;
+  readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
+  moduleName?: string | string[];
+  readonly disableDebug?: boolean;
+}): MockLoggerReturn {
+  const lc = new LogCollector(params?.pass);
+  let modNames = ["MockLogger"];
+  if (typeof params?.moduleName === "string") {
+    modNames = [params?.moduleName];
+  } else if (Array.isArray(params?.moduleName)) {
+    modNames = [...params.moduleName, ...modNames];
+  }
+  const logger = new LoggerImpl({
+    out: lc,
+    sys: params?.sys,
+    levelHandler: new LevelHandlerImpl(),
+  })
+    .With()
+    .Module(modNames[0])
+    .Logger();
+  if (!params?.disableDebug) {
+    logger.SetDebug(...modNames);
+  }
+  return {
+    logCollector: lc,
+    logger,
+  };
+}

package/src/time.ts

@@ -0,0 +1,20 @@
+export abstract class Time {
+  abstract Now(add?: number): Date;
+  abstract Sleep(duration: Duration): Promise<void>;
+  TimeSince(start: Date): Duration {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+}
+
+export type Duration = number;
+
+export enum TimeUnits {
+  Microsecond = 1,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Second = 1000 * Microsecond,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Minute = 60 * Second,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Hour = 60 * Minute,
+}