@adviser/cement 0.2.28 → 0.2.30

package/src/resolve-once.ts

@@ -0,0 +1,179 @@
+import { Future } from "./future.js";
+
+interface ResolveSeqItem<T, C> {
+  readonly future: Future<T>;
+  readonly fn: (c: C) => Promise<T>;
+  readonly id?: number;
+}
+
+export class ResolveSeq<T, C = void> {
+  readonly ctx: C;
+  constructor(ctx?: C) {
+    this.ctx = ctx as C;
+  }
+  reset(): void {
+    /* noop */
+  }
+  async _step(item?: ResolveSeqItem<T, C> | undefined): Promise<void> {
+    if (!item) {
+      // done
+      return;
+    }
+    item
+      .fn(this.ctx)
+      .then((value) => item.future.resolve(value))
+      .catch((e) => item.future.reject(e as Error))
+      .finally(() => {
+        this._seqFutures.shift();
+        this._step(this._seqFutures[0]);
+      });
+  }
+  readonly _seqFutures: ResolveSeqItem<T, C>[] = [];
+  async add(fn: (c: C) => Promise<T>, id?: number): Promise<T> {
+    const future = new Future<T>();
+    this._seqFutures.push({ future, fn, id });
+    if (this._seqFutures.length === 1) {
+      this._step(this._seqFutures[0]);
+    }
+    return future.asPromise();
+  }
+}
+
+export class ResolveOnce<T, CTX = void> {
+  _onceDone = false;
+  readonly _onceFutures: Future<T>[] = [];
+  _onceOk = false;
+  _onceValue?: T;
+  _onceError?: Error;
+  _isPromise = false;
+
+  readonly ctx: CTX;
+
+  constructor(ctx?: CTX) {
+    this.ctx = ctx as CTX;
+  }
+
+  get ready(): boolean {
+    return this._onceDone;
+  }
+
+  reset(): void {
+    this._onceDone = false;
+    this._onceOk = false;
+    this._onceValue = undefined;
+    this._onceError = undefined;
+    this._onceFutures.length = 0;
+  }
+
+  // T extends Option<infer U> ? U : T
+  once<R>(fn: (c: CTX) => R): R {
+    if (this._onceDone) {
+      if (this._onceError) {
+        if (this._isPromise) {
+          return Promise.reject(this._onceError) as unknown as R;
+        } else {
+          throw this._onceError;
+        }
+      }
+      if (this._onceOk) {
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          return Promise.resolve(this._onceValue!) as unknown as R;
+        } else {
+          return this._onceValue as unknown as R;
+        }
+      }
+      throw new Error("ResolveOnce.once impossible");
+    }
+    const future = new Future<T>();
+    this._onceFutures.push(future);
+    if (this._onceFutures.length === 1) {
+      const okFn = (value: T): void => {
+        this._onceValue = value;
+        this._onceOk = true;
+        this._onceDone = true;
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this._onceFutures.forEach((f) => f.resolve(this._onceValue!));
+        }
+        this._onceFutures.length = 0;
+      };
+      const catchFn = (e: Error): void => {
+        this._onceError = e as Error;
+        this._onceOk = false;
+        this._onceValue = undefined;
+        this._onceDone = true;
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this._onceFutures.forEach((f) => f.reject(this._onceError!));
+        }
+        this._onceFutures.length = 0;
+      };
+      try {
+        const ret = fn(this.ctx);
+        if (typeof (ret as Promise<T>).then === "function") {
+          this._isPromise = true;
+          (ret as Promise<T>).then(okFn).catch(catchFn);
+        } else {
+          okFn(ret as unknown as T);
+        }
+      } catch (e) {
+        catchFn(e as Error);
+      }
+    }
+    if (this._isPromise) {
+      return future.asPromise() as unknown as R;
+    } else {
+      // abit funky but i don't want to impl the return just once
+      return this.once(fn);
+    }
+  }
+}
+
+export class Keyed<T extends { reset: () => void }, K = string> {
+  private readonly _map = new Map<K, T>();
+
+  readonly factory: (key: K) => T;
+  constructor(factory: (key: K) => T) {
+    this.factory = factory;
+  }
+
+  async asyncGet(key: () => Promise<K>): Promise<T> {
+    return this.get(await key());
+  }
+
+  get(key: K | (() => K)): T {
+    if (typeof key === "function") {
+      key = (key as () => K)();
+    }
+    let keyed = this._map.get(key);
+    if (!keyed) {
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
+    }
+    return keyed;
+  }
+
+  unget(key: K): void {
+    const keyed = this._map.get(key);
+    keyed?.reset();
+    this._map.delete(key);
+  }
+
+  reset(): void {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
+  }
+}
+
+export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K> {
+  constructor() {
+    super((key) => new ResolveOnce<T, K>(key));
+  }
+}
+
+export class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
+  constructor() {
+    super((key) => new ResolveSeq<T, K>(key));
+  }
+}

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.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();