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

package/package.json

@@ -1,34 +1,45 @@
 {
   "name": "@adviser/cement",
-  "version": "0.0.0-jsr-t1",
+  "version": "0.0.0-smoke-ci",
   "description": "better try/catch/finally handling",
-  "main": "index.js",
+  "main": "./cjs/index.js",
   "type": "module",
+  "bin": "./src/cli/run.sh",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "require": "./index.cjs",
-      "import": "./index.js"
+      "types": "./esm/index.d.ts",
+      "require": "./cjs/index.cjs",
+      "import": "./esm/index.js"
+    },
+    "./cli": {
+      "types": "./esm/cli/index.d.ts",
+      "require": "./cjs/cli/index.cjs",
+      "import": "./esm/cli/index.js"
     },
     "./web": {
-      "types": "./web/index.d.ts",
-      "require": "./web/index.cjs",
-      "import": "./web/index.js"
+      "types": "./esm/web/index.d.ts",
+      "require": "./cjs/web/index.cjs",
+      "import": "./esm/web/index.js"
     },
     "./utils": {
-      "types": "./utils/index.d.ts",
-      "require": "./utils/index.cjs",
-      "import": "./utils/index.js"
+      "types": "./esm/utils/index.d.ts",
+      "require": "./cjs/utils/index.cjs",
+      "import": "./esm/utils/index.js"
+    },
+    "./cf": {
+      "types": "./esm/cf/index.d.ts",
+      "require": "./cjs/cf/index.cjs",
+      "import": "./esm/cf/index.js"
     },
     "./node": {
-      "types": "./node/index.d.ts",
-      "require": "./node/index.cjs",
-      "import": "./node/index.js"
+      "types": "./esm/node/index.d.ts",
+      "require": "./cjs/node/index.cjs",
+      "import": "./esm/node/index.js"
     },
     "./deno": {
-      "types": "./node/index.d.ts",
-      "require": "./node/index.cjs",
-      "import": "./node/index.js"
+      "types": "./esm/deno/index.d.ts",
+      "require": "./cjs/deno/index.cjs",
+      "import": "./esm/deno/index.js"
     }
   },
   "keywords": [],
@@ -40,40 +51,55 @@
   "homepage": "https://github.com/mabels/cement#readme",
   "dependencies": {
     "ts-essentials": "^10.0.2",
-    "yaml": "^2.5.1"
+    "yaml": "^2.7.1"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.2.0",
-    "@typescript-eslint/parser": "^8.3.0",
-    "@vitest/browser": "^2.0.5",
+    "@cloudflare/vitest-pool-workers": "^0.8.44",
+    "@eslint/js": "^9.20.0",
+    "@types/deno": "^2.3.0",
+    "@types/node": "^24.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "@typescript/native-preview": "7.0.0-dev.20250804.1",
+    "@vitest/browser": "^3.2.4",
+    "cmd-ts": "^0.13.0",
+    "deno": "2.4.3",
     "esbuild-plugin-replace": "^1.4.0",
     "esbuild-plugin-resolve": "^2.0.0",
-    "eslint": "^9.8.0",
-    "prettier": "^3.2.5",
-    "tsup": "^8.1.0",
-    "tsx": "^4.16.0",
-    "typescript": "^5.5.0",
-    "typescript-eslint": "^8.2.0",
+    "eslint": "9.32.0",
+    "jscodeshift": "^17.3.0",
+    "playwright": "^1.54.1",
+    "playwright-chromium": "^1.54.1",
+    "prettier": "^3.6.2",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.24.0",
+    "vite": "^7.0.4",
     "vite-tsconfig-paths": "^5.0.1",
-    "vitest": "^2.0.5",
-    "webdriverio": "^9.0.7"
+    "vitest": "^3.2.4",
+    "zx": "^8.8.0"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20.19.0"
   },
   "scripts": {
     "clean": "rm -rf dist node_modules",
-    "build": "pnpm run build:tsc; pnpm run build:js",
-    "build:tsc": "tsc",
-    "xbuild:js": "tsup",
-    "build:js": "tsup --out-dir dist/pkg src/index.ts src/*/index.ts --sourcemap --format cjs,esm --dts --clean --external node:fs --external node:path",
-    "test": "pnpm run test:js",
-    "test:deno": "deno run --allow-net --allow-write --allow-run  --allow-sys --allow-ffi  --allow-read --allow-env  ./node_modules/vitest/vitest.mjs --run --project node",
+    "build": "pnpm run build:tsgo; pnpm run build:js; pnpm run build:deno",
+    "build:tsc": "rm -rf ./dist/ts ; pnpm run /^build:tsc:/",
+    "build:tsgo": "rm -rf ./dist/ts ; pnpm run /^build:tsgo:/",
+    "build:tsgo:global": "tsgo --noEmit",
+    "build:tsgo:esm": "tsgo -p ./tsconfig.esm.json; src/cli/run.sh generateVersionTs -t ./tsconfig.esm.json",
+    "build:tsgo:cjs": "tsgo -p ./tsconfig.cjs.json; src/cli/run.sh generateVersionTs -t ./tsconfig.cjs.json",
+    "build:js": "rm -rf dist/pkg ; mkdir -p dist/pkg; cp -pr ./dist/ts/* dist/pkg",
+    "build:deno": "deno publish --dry-run --unstable-sloppy-imports --allow-dirty --set-version 0.0.0-dev",
+    "test": "pnpm run test:js; pnpm run test:deno",
+    "test:deno": "deno run --quiet --allow-net --allow-write --allow-run  --allow-sys --allow-ffi  --allow-read --allow-env  ./node_modules/vitest/vitest.mjs --run --project node",
     "test:js": "vitest --run",
-    "pubdir": "bash ./prepare-pubdir.sh",
+    "pubdir": "src/cli/run.sh preparePubdir",
     "presmoke": "pnpm run pubdir ; cd pubdir ; pnpm pack",
-    "smoke": "cd smoke; rm -f package.json; pnpm init ; pnpm install -f ../pubdir/adviser-cement-*.tgz; npx tsx ./smoke.ts; deno run --allow-read ./smoke.ts",
+    "deno:publish": "pnpm run pubdir; cd pubdir ; pnpm exec deno publish --allow-dirty --unstable-sloppy-imports",
+    "smoke": "bash ./smoke/it.sh",
     "lint": "eslint .",
     "prettier": "prettier .",
     "format": "prettier ."

package/src/app-context.ts

@@ -0,0 +1,49 @@
+/*
+ * Context class to store and retrieve values
+ * it's used to store user runtime values like
+ * the url to the ledger
+ */
+
+export function isAppContext(ctx: unknown): ctx is AppContext {
+  return AppContext.is(ctx);
+}
+
+export class AppContext {
+  private readonly ctx: Map<string, unknown> = new Map<string, unknown>();
+
+  static is(ctx: unknown): ctx is AppContext {
+    return ctx instanceof AppContext && "ctx" in ctx && ctx.ctx instanceof Map;
+  }
+
+  static merge(...ctxs: (AppContext | undefined | Record<string, unknown>)[]): AppContext {
+    const merged = new AppContext();
+    for (const ctx of ctxs) {
+      if (!ctx) continue;
+      let entries: [string, unknown][] = [];
+      if (isAppContext(ctx)) {
+        entries = Array.from(ctx.ctx.entries());
+      } else if (typeof ctx === "object" && ctx !== null) {
+        entries = Object.entries(ctx);
+      }
+      for (const [key, value] of entries) {
+        merged.ctx.set(key, value);
+      }
+    }
+    return merged;
+  }
+
+  set<T>(key: string, value: T): AppContext {
+    this.ctx.set(key, value);
+    return this;
+  }
+  get<T>(key: string): T | undefined {
+    return this.ctx.get(key) as T;
+  }
+  delete(key: string): void {
+    this.ctx.delete(key);
+  }
+
+  asObj(): Record<string, unknown> {
+    return Object.fromEntries(this.ctx.entries());
+  }
+}

package/src/base-sys-abstraction.ts

@@ -1,7 +1,21 @@
 import { FileService } from "./file-service.js";
-import { TimeMode, RandomMode, IDMode, SystemService, VoidFunc, SysAbstraction } from "./sys-abstraction.js";
+import { runtimeFn } from "./runtime.js";
+import {
+  TimeMode,
+  RandomMode,
+  IDMode,
+  SystemService,
+  VoidFunc,
+  BasicSysAbstraction,
+  BasicRuntimeService,
+} from "./sys-abstraction.js";
 import { Time } from "./time.js";
 import { TxtEnDecoder } from "./txt-en-decoder.js";
+import { WebBasicSysAbstraction } from "./web/web-basic-sys-abstraction.js";
+import { Env } from "./sys-env.js";
+import { CFBasicSysAbstraction } from "./cf/cf-basic-sys-abstraction.js";
+import { DenoBasicSysAbstraction } from "./deno/deno-basic-sys-abstraction.js";
+import { NodeBasicSysAbstraction } from "./node/node-basic-sys-abstraction.js";
 
 export class SysTime extends Time {
   Now(): Date {
@@ -110,8 +124,11 @@ export class IdService {
   }
 }
 
-export interface BaseSysAbstractionParams {
+export interface BaseBasicSysAbstractionParams {
   readonly TxtEnDecoder: TxtEnDecoder;
+}
+
+export interface BaseSysAbstractionParams extends BaseBasicSysAbstractionParams {
   readonly FileSystem: FileService;
   readonly SystemService: SystemService;
 }
@@ -126,96 +143,85 @@ export interface ExitService {
   exit(code: number): void;
 }
 
-export class BaseSysAbstraction {
+// some black magic to make it work with CF workers
+
+export class BaseBasicSysAbstraction {
   readonly _time: SysTime = new SysTime();
-  readonly _stdout: WritableStream;
-  readonly _stderr: WritableStream;
 
+  // system independent services
   readonly _idService: IdService = new IdService();
   readonly _randomService: RandomService = new RandomService(RandomMode.RANDOM);
+  readonly _txtEnDe: TxtEnDecoder;
+
+  constructor(params: BaseBasicSysAbstractionParams) {
+    this._txtEnDe = params.TxtEnDecoder;
+  }
+}
+
+export class BaseSysAbstraction extends BaseBasicSysAbstraction {
+  // system related services
   readonly _fileSystem: FileService;
   readonly _systemService: SystemService;
-  readonly _txtEnDe: TxtEnDecoder;
 
   constructor(params: BaseSysAbstractionParams) {
+    super(params);
     this._fileSystem = params.FileSystem;
     this._systemService = params.SystemService;
-    this._txtEnDe = params.TxtEnDecoder;
-    const decoder = this._txtEnDe;
-    this._stdout = new WritableStream({
-      write(chunk): Promise<void> {
-        return new Promise((resolve) => {
-          const decoded = decoder.decode(chunk);
-          // eslint-disable-next-line no-console
-          console.log(decoded.trimEnd());
-          resolve();
-        });
-      },
-    });
-    this._stderr = new WritableStream({
-      write(chunk): Promise<void> {
-        return new Promise((resolve) => {
-          const decoded = decoder.decode(chunk);
-          // eslint-disable-next-line no-console
-          console.error(decoded.trimEnd());
-          resolve();
-        });
-      },
-    });
   }
 }
 
-export interface WrapperSysAbstractionParams {
-  readonly TimeMode?: TimeMode;
-  readonly IdMode?: IDMode;
-  readonly Stdout?: WritableStream<Uint8Array>;
-  readonly Stderr?: WritableStream<Uint8Array>;
-  readonly RandomMode?: RandomMode;
-  readonly FileSystem?: FileService;
-  readonly SystemService?: SystemService;
-  readonly TxtEnDecoder?: TxtEnDecoder;
+export interface BasicSysAbstractionParams {
+  readonly TimeMode: TimeMode;
+  readonly IdMode: IDMode;
+  readonly RandomMode: RandomMode;
+  // readonly FileSystem: FileService;
+  // readonly SystemService: SystemService;
+  readonly TxtEnDecoder: TxtEnDecoder;
+  // readonly BasicRuntimeService: BasicSysAbstraction;
 }
 
-export class WrapperSysAbstraction implements SysAbstraction {
+export type WrapperBasicSysAbstractionParams = Partial<BasicRuntimeService & BasicSysAbstractionParams>;
+
+export function BasicSysAbstractionFactory(params?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const fn = runtimeFn();
+  switch (true) {
+    case fn.isBrowser:
+      return WebBasicSysAbstraction(params);
+    case fn.isDeno:
+      return DenoBasicSysAbstraction(params);
+    case fn.isCFWorker:
+      return CFBasicSysAbstraction(params);
+    case fn.isNodeIsh:
+      return NodeBasicSysAbstraction(params);
+    default:
+      throw new Error("Unknown runtime");
+  }
+}
+
+export class WrapperBasicSysAbstraction implements BasicSysAbstraction {
   readonly _time: Time;
-  readonly _stdout: WritableStream<Uint8Array>;
-  readonly _stderr: WritableStream<Uint8Array>;
   readonly _idService: IdService;
   readonly _randomService: RandomService;
-  readonly _fileSystem: FileService;
-  readonly _systemService: SystemService;
-  constructor(base: BaseSysAbstraction, params?: WrapperSysAbstractionParams) {
+  readonly _basicRuntimeService: BasicRuntimeService;
+  constructor(
+    base: BaseBasicSysAbstraction,
+    params: Partial<BasicSysAbstractionParams> & { basicRuntimeService: BasicRuntimeService },
+  ) {
     this._time = base._time;
-    this._stdout = base._stdout;
-    this._stderr = base._stderr;
+    this._basicRuntimeService = params.basicRuntimeService;
     this._idService = base._idService;
     this._randomService = base._randomService;
-    this._fileSystem = base._fileSystem;
-    this._systemService = base._systemService;
-    if (params) {
-      if (params.TimeMode) {
-        this._time = TimeFactory(params.TimeMode);
-      }
-      if (params.Stdout) {
-        this._stdout = params.Stdout;
-      }
-      if (params.Stderr) {
-        this._stderr = params.Stderr;
-      }
-      if (params.IdMode) {
-        this._idService = new IdService(params.IdMode);
-      }
-      if (params.RandomMode) {
-        this._randomService = new RandomService(params.RandomMode);
-      }
-      if (params.FileSystem) {
-        this._fileSystem = params.FileSystem;
-      }
-      if (params.SystemService) {
-        this._systemService = params.SystemService;
-      }
+    if (params.TimeMode) {
+      this._time = TimeFactory(params.TimeMode);
+    }
+    if (params.IdMode) {
+      this._idService = new IdService(params.IdMode);
+    }
+    if (params.RandomMode) {
+      this._randomService = new RandomService(params.RandomMode);
     }
   }
+
   Time(): Time {
     return this._time;
   }
@@ -226,10 +232,41 @@ export class WrapperSysAbstraction implements SysAbstraction {
     return this._randomService.Random0ToValue(value);
   }
   Stdout(): WritableStream {
-    return this._stdout;
+    return this._basicRuntimeService.Stdout();
   }
   Stderr(): WritableStream {
-    return this._stderr;
+    return this._basicRuntimeService.Stderr();
+  }
+  Env(): Env {
+    return this._basicRuntimeService.Env();
+  }
+  Args(): string[] {
+    return this._basicRuntimeService.Args();
+  }
+
+  // System(): SystemService {
+  //   return this._systemService;
+  // }
+  // FileSystem(): FileService {
+  //   return this._fileSystem;
+  // }
+}
+// export const BaseSysAbstraction = new BaseSysAbstractionImpl()
+
+export class WrapperRuntimeSysAbstraction extends WrapperBasicSysAbstraction {
+  readonly _systemService: SystemService;
+  readonly _fileSystem: FileService;
+  constructor(
+    base: BaseSysAbstraction,
+    params: Partial<BaseBasicSysAbstraction> & {
+      systemService?: SystemService;
+      fileSystem?: FileService;
+      basicRuntimeService: BasicRuntimeService;
+    },
+  ) {
+    super(base, params);
+    this._systemService = params.systemService ?? base._systemService;
+    this._fileSystem = params.fileSystem ?? base._fileSystem;
   }
 
   System(): SystemService {
@@ -239,4 +276,3 @@ export class WrapperSysAbstraction implements SysAbstraction {
     return this._fileSystem;
   }
 }
-// export const BaseSysAbstraction = new BaseSysAbstractionImpl()

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

@@ -0,0 +1,79 @@
+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 CFRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+  }
+  Env(): Env {
+    return envFactory();
+  }
+  Args(): string[] {
+    throw new Error("Args-Method not implemented.");
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.log(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.error(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+}
+
+function consumeReadableStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  writeFn: (chunk: Uint8Array) => Promise<void>,
+): void {
+  reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        return;
+      }
+      writeFn(value)
+        .then(() => {
+          consumeReadableStream(reader, writeFn);
+        })
+        .catch((e) => {
+          // eslint-disable-next-line no-console
+          console.error("consumeReadableStream:writeFn", e);
+        });
+    })
+    .catch((e) => {
+      // eslint-disable-next-line no-console
+      console.error("consumeReadableStream:read", e);
+    });
+}
+
+function CFWriteableStream(writeFn: (chunk: Uint8Array) => Promise<void>): WritableStream<Uint8Array> {
+  const ts = new TransformStream<Uint8Array, Uint8Array>();
+  consumeReadableStream(ts.readable.getReader(), writeFn);
+  return ts.writable;
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function CFBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new CFRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}

package/src/cf/cf-env-actions.ts

@@ -0,0 +1,53 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { EnvActions, EnvImpl, EnvFactoryOpts, Env } from "../sys-env.js";
+
+const once = new ResolveOnce<CFEnvActions>();
+export class CFEnvActions implements EnvActions {
+  readonly injectOnRegister: Record<string, string> = {};
+  readonly cfEnv: Map<string, string>;
+  env?: EnvImpl;
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new CFEnvActions(opts));
+  }
+  static inject(o: Record<string, string>): void {
+    const env = CFEnvActions.new({}) as CFEnvActions;
+    for (const key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        if (env.env) {
+          env.env.set(key, value);
+        } else {
+          env.injectOnRegister[key] = value;
+        }
+      }
+    }
+  }
+  private constructor(env: Partial<EnvFactoryOpts>) {
+    this.cfEnv = new Map<string, string>(Object.entries(env.presetEnv || {}));
+  }
+  active(): boolean {
+    return runtimeFn().isCFWorker;
+  }
+  register(env: Env): Env {
+    this.env = env as EnvImpl;
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
+    }
+    return env;
+  }
+  get(key: string): string | undefined {
+    return this.cfEnv.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.cfEnv.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.cfEnv.keys());
+  }
+}

package/src/cf/index.ts

@@ -0,0 +1,2 @@
+export * from "./cf-basic-sys-abstraction.js";
+export * from "./cf-env-actions.js";

package/src/cf-test-main.ts

@@ -0,0 +1,14 @@
+import { LoggerImpl } from "@adviser/cement";
+
+export default {
+  fetch(): Response {
+    // console.log(">>>>enter");
+    const logger = new LoggerImpl();
+    for (let i = 0; i < 10; i++) {
+      logger.Error().Any({ i }).Msg("Hello Logger World!");
+    }
+    const ret = new Response("Hello World!");
+    // console.log(">>>>exit");
+    return ret;
+  },
+};

package/src/cli/index.ts

@@ -0,0 +1 @@
+export * from "./patch-version-cmd.js";

package/src/cli/main.ts

@@ -0,0 +1,19 @@
+import { run, subcommands } from "cmd-ts";
+import { patchVersionCmd, generateVersionTsCmd, setUpDenoJsonCmd, preparePubdirCmd } from "./patch-version-cmd.js";
+
+(async (): Promise<void> => {
+  const cmd = subcommands({
+    name: "cement",
+    description: "cement cli",
+    version: "1.0.0",
+    cmds: {
+      patchVersion: patchVersionCmd(),
+      generateVersionTs: generateVersionTsCmd(),
+      setUpDenoJson: setUpDenoJsonCmd(),
+      preparePubdir: preparePubdirCmd(),
+    },
+  });
+
+  await run(cmd, process.argv.slice(2));
+  // eslint-disable-next-line no-console
+})().catch(console.error);