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

package/src/sys-env.ts

@@ -1,4 +1,12 @@
-import { ResolveOnce } from "./resolve-once.js";
+import { DenoEnvActions } from "./deno/deno-env-actions.js";
+import { NodeEnvActions } from "./node/node-env-actions.js";
+import { BrowserEnvActions } from "./web/web-env-actions.js";
+import { CFEnvActions } from "./cf/cf-env-actions.js";
+import { KeyedResolvOnce } from "./resolve-once.js";
+import { Result } from "./result.js";
+import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
+
+export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
 export interface EnvMap {
   get(key: string): string | undefined;
@@ -11,109 +19,10 @@ export interface EnvActions extends EnvMap {
   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>;
+  readonly id: string; // to reinit in tests
 }
 
 type OnSetFn = (key: string, value?: string) => void;
@@ -124,27 +33,106 @@ export interface OnSetItem {
 
 export interface Env extends EnvMap {
   onSet(fn: OnSetFn, ...filter: string[]): void;
+
+  gets(...kparams: KeysParam): Result<Record<string, string>>;
+  sets(...keys: EnvTuple): 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");
+export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
+
+const envActions: { id: string; fn: EnvFactoryFn }[] = [
+  { id: "cf", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => CFEnvActions.new(opts) },
+  { id: "node", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => NodeEnvActions.new(opts) },
+  { id: "deno", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => DenoEnvActions.new(opts) },
+  { id: "browser", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => BrowserEnvActions.new(opts) },
+];
+
+export function registerEnvAction(fn: EnvFactoryFn): () => void {
+  const id = `id-${Math.random()}`;
+  envActions.unshift({ id, fn });
+  // rerun envFactory
+  _envFactories.unget(id);
+  return () => {
+    const index = envActions.findIndex((i) => i.id === id);
+    if (index >= 0) {
+      envActions.splice(index, 1);
     }
-    const ret = new EnvImpl(found, opts);
-    found.register(ret);
+  };
+}
+
+const _envFactories = new KeyedResolvOnce<Env>();
+export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
+  const found = envActions.find((fi) => fi.fn(opts).active());
+  if (!found) {
+    throw new Error("SysContainer:envFactory: no env available");
+  }
+  return _envFactories.get(opts.id ?? found.id).once(() => {
+    const action = found.fn(opts);
+    const ret = new EnvImpl(action, opts);
+    action.register(ret);
     return ret;
   });
 }
 
+function isIterable(obj: unknown): obj is Iterable<[string, string]> {
+  // checks for null and undefined
+  if (obj == null) {
+    return false;
+  }
+  return typeof (obj as Record<symbol, unknown>)[Symbol.iterator] === "function";
+}
+
 export class EnvImpl implements Env {
   readonly _map: EnvMap;
   constructor(map: EnvMap, opts: Partial<EnvFactoryOpts> = {}) {
     this._map = map;
     this._updatePresets(opts.presetEnv);
   }
+  gets(...kparams: KeysParam): Result<Record<string, string>> {
+    return getParamsResult(kparams, {
+      getParam: (k) => this.get(k),
+    });
+  }
+  sets(...keys: EnvTuple): void {
+    keys.forEach((key) => {
+      if (Array.isArray(key)) {
+        if (key.length === 2) {
+          const [k, v] = key;
+          if (typeof k === "string" && typeof v === "string") {
+            this.set(k, v);
+            return;
+          }
+        }
+        for (const item of key) {
+          if (Array.isArray(item)) {
+            // [string, string]
+            if (item.length === 2) {
+              const [k, v] = item;
+              if (typeof k === "string" && typeof v === "string") {
+                this.set(k, v);
+              }
+            }
+          }
+        }
+      } else {
+        if (isIterable(key)) {
+          for (const [k, v] of key) {
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        } else {
+          const rKey = key as Record<string, string>;
+          for (const k in rKey) {
+            const v = rKey[k];
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        }
+      }
+    });
+  }
   _updatePresets(presetEnv?: Map<string, string>): void {
     if (!presetEnv) {
       return;
@@ -172,7 +160,7 @@ export class EnvImpl implements Env {
           return false;
         })
         .forEach((k) => {
-          let v;
+          let v: string | undefined;
           if (!key && !value) {
             // init
             v = this._map.get(k);

package/src/test/index.ts

@@ -0,0 +1,2 @@
+export * from "./log-write-stream.js";
+export * from "./mock-logger.js";

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

@@ -1,6 +1,6 @@
 import { FanoutWriteStream } from "../utils/fanout-write-stream.js";
 import { Future } from "../future.js";
-import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   private readonly _bufferArr: Uint8Array[];
@@ -12,7 +12,7 @@ export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   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);
+  readonly ready: Promise<never> = Promise.resolve() as Promise<never>;
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
   abort(reason?: any): Promise<void> {
@@ -20,7 +20,7 @@ export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   }
   async close(): Promise<void> {
     await this.closed;
-    return Promise.resolve(undefined);
+    return Promise.resolve();
   }
   releaseLock(): void {
     // do nothing
@@ -29,7 +29,7 @@ export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
     if (chunk) {
       this._bufferArr.push(chunk);
     }
-    return Promise.resolve(undefined);
+    return Promise.resolve();
   }
 }
 
@@ -42,7 +42,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
 
   constructor(pass?: WritableStreamDefaultWriter<Uint8Array>, txtEnDe?: TxtEnDecoder) {
     this._pass = pass;
-    this._txtEnDe = txtEnDe || Utf8EnDecoderSingleton();
+    this._txtEnDe = txtEnDe || TxtEnDecoderSingleton();
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -56,12 +56,12 @@ export class LogCollector implements WritableStream<Uint8Array> {
       this._writer = undefined;
       return ret;
     }
-    return Promise.resolve(undefined);
+    return Promise.resolve();
   }
 
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (!this._writer) {
-      const dests: WritableStreamDefaultWriter[] = [new LogWriteStream(this._bufferArr)];
+      const dests: WritableStreamDefaultWriter<Uint8Array>[] = [new LogWriteStream(this._bufferArr)];
       if (this._pass) {
         dests.push(this._pass);
       }
@@ -87,6 +87,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
     if (!notJsonLine) {
       const splitStr = jsonNlStr.split("\n");
       const filterStr = splitStr.filter((a) => a.length);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const mapStr = filterStr.map((a) => JSON.parse(a));
       return mapStr;
     }

package/src/test/mock-logger.ts

@@ -1,8 +1,8 @@
 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";
+import { BasicSysAbstraction } from "../sys-abstraction.js";
 
 export interface MockLoggerReturn {
   readonly logger: Logger;
@@ -10,7 +10,7 @@ export interface MockLoggerReturn {
 }
 
 export function MockLogger(params?: {
-  readonly sys?: SysAbstraction;
+  readonly sys?: BasicSysAbstraction;
   readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
   moduleName?: string | string[];
   readonly disableDebug?: boolean;

package/src/time.ts

@@ -9,12 +9,10 @@ export abstract class Time {
 
 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,
-}
+export const TimeUnits = {
+  Microsecond: 1,
+  Second: 1000 * 1, //Microsecond,
+  Minute: 60 * 1000 * 1, //Second,
+  Hour: 60 * 60 * 1000 * 1, // Minute,
+};
+export type TimeUnit = keyof typeof TimeUnits;

package/src/tracer.ts

@@ -1,6 +1,7 @@
 import type { MarkWritable } from "ts-essentials";
 import { Time } from "./time.js";
 import { Logger } from "./logger.js";
+import { isPromise } from "./is-promise.js";
 
 export type TraceCtx = {
   readonly spanId: string;
@@ -38,14 +39,12 @@ export class Metric<T> {
   add<R extends number | ArrayLike<T>>(value: R): void {
     if (typeof value === "number") {
       if (this.value === undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = 0 as any;
+        this.value = 0 as T;
       }
-      (this.value as number) = ((this.value as number) + value) as number;
+      this.value = ((this.value as number) + value) as T;
     } else if (Array.isArray(value)) {
       if (!Array.isArray(this.value)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = [] as any;
+        this.value = [] as T;
       }
       (this.value as T[]).push(...value);
     } else {
@@ -142,10 +141,10 @@ export class TraceNode {
     delete cleanCtx.time;
     delete cleanCtx.logger;
     delete cleanCtx.metrics;
-    const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs });
+    const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs }) as Record<string, unknown>;
     const metricsRefs = Object.keys(spanRefs).length > 0 ? { metricRefs: spanRefs } : {};
     return {
-      ctx: cleanCtx as CleanCtx,
+      ctx: cleanCtx,
       invokations: this.invokations,
       ...metricsRefs,
     };
@@ -198,10 +197,10 @@ export class TraceNode {
     spanTrace.invokations.push(invokation);
     try {
       const possiblePromise = fn(spanTrace);
-      if (possiblePromise instanceof Promise) {
+      if (isPromise(possiblePromise)) {
         return possiblePromise
           .then((v) => {
-            return v;
+            return v as ReturnType<V>;
           })
           .catch((e) => {
             invokation.result = "error";

package/src/txt-en-decoder.ts

@@ -1,21 +1,50 @@
+import { ResolveOnce } from "./resolve-once.js";
+import { Result } from "./result.js";
+import { coerceIntoUint8, ToUInt8 } from "./utils/coerce-uint8.js";
+
+export type ToEnDecoder = ToUInt8 | string | Result<string>;
+export type AsyncToEnDecoder = ToEnDecoder | Blob | Promise<ToEnDecoder | Blob>;
+
 export interface TxtEnDecoder {
-  encode(str: string): Uint8Array;
-  decode(data: Uint8Array): string;
+  encode(input: string): Uint8Array;
+  decode(input: ToEnDecoder): string;
+  asyncDecode(input: AsyncToEnDecoder): Promise<string>;
 }
 
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+class TxtOps implements TxtEnDecoder {
+  readonly encoder = new TextEncoder();
+  readonly decoder = new TextDecoder();
 
-export class Utf8EnDecoder implements TxtEnDecoder {
   encode(str: string): Uint8Array {
-    return encoder.encode(str);
+    return this.encoder.encode(str);
   }
-  decode(data: Uint8Array): string {
-    return decoder.decode(data);
+  decode(data: ToEnDecoder): string {
+    if (Result.Is(data)) {
+      if (data.isErr()) {
+        throw data.Err();
+      }
+      // only for string let do coerceInto the work
+      const unwrapped = data.unwrap();
+      if (typeof unwrapped === "string") {
+        return this.decode(unwrapped);
+      }
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    return this.decoder.decode(coerceIntoUint8(data as ToUInt8).Ok());
+  }
+
+  async asyncDecode(data: AsyncToEnDecoder): Promise<string> {
+    let resolved = await data;
+    if (resolved instanceof Blob) {
+      resolved = await resolved.arrayBuffer();
+    }
+    return this.decode(resolved);
   }
 }
 
-const utf8EnDecoder = new Utf8EnDecoder();
-export function Utf8EnDecoderSingleton(): TxtEnDecoder {
-  return utf8EnDecoder;
+const txtEnDecoder = new ResolveOnce<TxtEnDecoder>();
+export function TxtEnDecoderSingleton(): TxtEnDecoder {
+  return txtEnDecoder.once(() => new TxtOps());
 }

package/src/types.ts

@@ -0,0 +1,19 @@
+interface IType {
+  readonly type: string;
+}
+class _Required implements IType {
+  readonly type = "REQUIRED";
+}
+
+class _Optional implements IType {
+  readonly type = "OPTIONAL";
+}
+
+export const param: {
+  REQUIRED: _Required;
+  OPTIONAL: _Optional;
+} = {
+  REQUIRED: new _Required(),
+  OPTIONAL: new _Optional(),
+};
+export type param = (typeof param)[keyof typeof param];