@adviser/cement 0.2.28 → 0.2.29

package/src/crypto.test.ts

@@ -0,0 +1,15 @@
+import { toCryptoRuntime } from "./crypto.js";
+
+it("not extractable import -> export", async () => {
+  const cp = toCryptoRuntime();
+  const key = cp.randomBytes(32);
+  const x = await cp.importKey("raw", key, "AES-CBC", false, ["encrypt"]);
+  expect(cp.exportKey("raw", x)).rejects.toThrowError(/key is not extractable/i);
+});
+
+it("extractable import -> export", async () => {
+  const cp = toCryptoRuntime();
+  const key = cp.randomBytes(32);
+  const x = await cp.importKey("raw", key, "AES-CBC", true, ["encrypt"]);
+  expect(new Uint8Array((await cp.exportKey("raw", x)) as ArrayBuffer)).toEqual(key);
+});

package/src/crypto.ts

@@ -0,0 +1,125 @@
+export interface CTJsonWebKey {
+  alg?: string;
+  crv?: string;
+  d?: string;
+  dp?: string;
+  dq?: string;
+  e?: string;
+  ext?: boolean;
+  k?: string;
+  key_ops?: string[];
+  kty?: string;
+  n?: string;
+  oth?: RsaOtherPrimesInfo[];
+  p?: string;
+  q?: string;
+  qi?: string;
+  use?: string;
+  x?: string;
+  y?: string;
+}
+
+export type CTKeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
+export type CTKeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+
+export interface CTAlgorithm {
+  name: string;
+}
+export type CTAlgorithmIdentifier = CTAlgorithm | string;
+
+export interface CTRsaHashedImportParams extends CTAlgorithm {
+  hash: CTAlgorithmIdentifier;
+}
+
+export type CTNamedCurve = string;
+export interface CTEcKeyImportParams extends CTAlgorithm {
+  namedCurve: CTNamedCurve;
+}
+
+export interface CTHmacImportParams extends CTAlgorithm {
+  hash: CTAlgorithmIdentifier;
+  length?: number;
+}
+
+export interface CTAesKeyAlgorithm extends CTAlgorithm {
+  length: number;
+}
+
+export type CTKeyType = "private" | "public" | "secret";
+
+export interface CTCryptoKey {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm) */
+  readonly algorithm: CTAlgorithm;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable) */
+  readonly extractable: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/type) */
+  readonly type: CTKeyType;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages) */
+  readonly usages: CTKeyUsage[];
+}
+
+interface CTArrayBufferTypes {
+  ArrayBuffer: ArrayBuffer;
+}
+type CTArrayBufferLike = CTArrayBufferTypes[keyof CTArrayBufferTypes];
+
+export interface CTArrayBufferView {
+  /**
+   * The ArrayBuffer instance referenced by the array.
+   */
+  buffer: CTArrayBufferLike;
+
+  /**
+   * The length in bytes of the array.
+   */
+  byteLength: number;
+
+  /**
+   * The offset in bytes of the array.
+   */
+  byteOffset: number;
+}
+
+export type CTBufferSource = CTArrayBufferView | ArrayBuffer;
+
+export interface CryptoRuntime {
+  importKey(
+    format: CTKeyFormat,
+    keyData: CTJsonWebKey | CTBufferSource,
+    algorithm: CTAlgorithmIdentifier | CTRsaHashedImportParams | CTEcKeyImportParams | CTHmacImportParams | CTAesKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: CTKeyUsage[],
+  ): Promise<CTCryptoKey>;
+  exportKey(format: CTKeyFormat, key: CTCryptoKey): Promise<CTJsonWebKey | ArrayBuffer>;
+
+  //(format: "raw", key: ArrayBuffer, algo: string, extractable: boolean, usages: string[]) => Promise<CryptoKey>;
+  decrypt(algo: { name: string; iv: Uint8Array; tagLength: number }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+  encrypt(algo: { name: string; iv: Uint8Array; tagLength: number }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+  digestSHA256(data: Uint8Array): Promise<ArrayBuffer>;
+  randomBytes(size: number): Uint8Array;
+}
+
+function randomBytes(size: number): Uint8Array {
+  const bytes = new Uint8Array(size);
+  if (size > 0) {
+    crypto.getRandomValues(bytes);
+  }
+  return bytes;
+}
+
+function digestSHA256(data: Uint8Array): Promise<ArrayBuffer> {
+  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
+}
+
+export function toCryptoRuntime(cryptoOpts: Partial<CryptoRuntime> = {}): CryptoRuntime {
+  const runtime = {
+    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    exportKey: cryptoOpts.exportKey || crypto.subtle.exportKey.bind(crypto.subtle),
+    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
+    randomBytes: cryptoOpts.randomBytes || randomBytes,
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256,
+  };
+  // console.log("cryptoOpts", cryptoOpts, opts)
+  return runtime;
+}

package/src/file-service.ts

@@ -0,0 +1,24 @@
+export interface NamedWritableStream {
+  readonly name: string;
+  readonly stream: WritableStream<Uint8Array>;
+}
+
+export interface FileService {
+  readonly baseDir: string;
+  create(fname: string): Promise<NamedWritableStream>;
+  readFileString(fname: string): Promise<string>;
+  writeFileString(fname: string, content: string): Promise<void>;
+
+  abs(fname: string): string;
+
+  join(...paths: string[]): string;
+
+  relative(from: string, to?: string): string;
+
+  dirname(fname: string): string;
+  basename(fname: string): string;
+
+  // nodeImport(fname: string): string;
+
+  isAbsolute(fname: string): boolean;
+}

package/src/future.test.ts

@@ -0,0 +1,32 @@
+import { Future } from "@adviser/cement";
+
+it("Create Future Happy", async () => {
+  const future = new Future();
+  const promise = future.asPromise();
+  expect(promise).toBeInstanceOf(Promise);
+
+  const asynced = new Promise((resolve, reject) => {
+    promise.then(resolve).catch(reject);
+  });
+  future.resolve("Hello World");
+
+  expect(await asynced).toBe("Hello World");
+});
+
+it("Create Future Sad", async () => {
+  const future = new Future();
+  const promise = future.asPromise();
+  expect(promise).toBeInstanceOf(Promise);
+
+  const asynced = new Promise((resolve, reject) => {
+    promise.then(resolve).catch(reject);
+  });
+  future.reject("Sad World");
+
+  try {
+    await asynced;
+    expect("Why").toBe("Sad World");
+  } catch (error) {
+    expect(error).toBe("Sad World");
+  }
+});

package/src/future.ts

@@ -0,0 +1,27 @@
+export class Future<T> {
+  readonly #promise: Promise<T>;
+  #resolveFn: (value: T) => void = () => {
+    throw new Error("This Promise is not working as expected.");
+  };
+  #rejectFn: (reason: unknown) => void = () => {
+    throw new Error("This Promise is not working as expected.");
+  };
+
+  constructor() {
+    this.#promise = new Promise<T>((resolve, reject) => {
+      this.#resolveFn = resolve;
+      this.#rejectFn = reject;
+    });
+  }
+
+  async asPromise(): Promise<T> {
+    return this.#promise;
+  }
+
+  resolve(value: T): void {
+    this.#resolveFn(value);
+  }
+  reject(reason: unknown): void {
+    this.#rejectFn(reason);
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from "./file-service.js";
+export * from "./logger-impl.js";
+export * from "./logger.js";
+export * from "./sys-abstraction.js";
+export * from "./sys-env.js";
+export * from "./time.js";
+export * from "./test/log-write-stream.js";
+export * from "./test/mock-logger.js";
+export * from "./txt-en-decoder.js";
+export * from "./log-level-impl.js";
+export * from "./result.js";
+export * from "./option.js";
+export * from "./future.js";
+export * from "./tracer.js";
+export * from "./resolve-once.js";
+export * from "./runtime.js";
+export * from "./uri.js";
+export * from "./crypto.js";
+export * from "./base-sys-abstraction.js";
+export * from "./bin2text.js";
+export * from "./version.js";
+export * as utils from "./utils/index.js";

package/src/jsr.json

@@ -0,0 +1,20 @@
+{
+  "name": "@adviser/cement",
+  "version": "0.2.29",
+  "exports": {
+    ".": "./index.ts",
+    "./web": "./web/index.ts",
+    "./node": "./node/index.ts",
+    "./deno": "./node/index.ts"
+  },
+  "imports": {
+    "yaml": "npm:yaml@^2.5.1",
+    "ts-essentials": "npm:ts-essentials@^10.0.2"
+  },
+  "license": "AFL-2.0",
+  "publish": {
+    "include": [
+      "**/*.ts"
+    ]
+  }
+}

package/src/log-level-impl.ts

@@ -0,0 +1,87 @@
+import { LevelHandler, Level } from "./logger.js";
+
+export class LevelHandlerImpl implements LevelHandler {
+  readonly _globalLevels: Set<Level> = new Set<Level>([Level.INFO, Level.ERROR, Level.WARN]);
+  readonly _modules: Map<string, Set<Level>> = new Map<string, Set<Level>>();
+  isStackExposed = false;
+  enableLevel(level: Level, ...modules: string[]): void {
+    if (modules.length == 0) {
+      this._globalLevels.add(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.set(p, new Set([...this._globalLevels, level]));
+      },
+      ...modules,
+    );
+  }
+  disableLevel(level: Level, ...modules: string[]): void {
+    if (modules.length == 0) {
+      this._globalLevels.delete(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.delete(p);
+      },
+      ...modules,
+    );
+  }
+
+  setExposeStack(enable?: boolean): void {
+    this.isStackExposed = !!enable;
+  }
+
+  forModules(level: Level, fnAction: (p: string) => void, ...modules: (string | string[])[]): void {
+    for (const m of modules.flat()) {
+      if (typeof m !== "string") {
+        continue;
+      }
+      const parts = m
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length);
+      for (const p of parts) {
+        fnAction(p);
+      }
+    }
+  }
+  setDebug(...modules: (string | string[])[]): void {
+    this.forModules(
+      Level.DEBUG,
+      (p) => {
+        this._modules.set(p, new Set([...this._globalLevels, Level.DEBUG]));
+      },
+      ...modules,
+    );
+  }
+  isEnabled(ilevel: unknown, module: unknown): boolean {
+    const level = ilevel as Level; // what if it's not a level?
+    if (typeof module === "string") {
+      const levels = this._modules.get(module);
+      if (levels && levels.has(level)) {
+        return true;
+      }
+    }
+    const wlevel = this._modules.get("*");
+    if (wlevel && typeof level === "string") {
+      if (wlevel.has(level)) {
+        return true;
+      }
+    }
+    if (typeof level !== "string") {
+      // this is a plain log
+      return true;
+    }
+    return this._globalLevels.has(level);
+  }
+}
+
+const levelSingleton = new LevelHandlerImpl();
+
+export function LevelHandlerSingleton(): LevelHandler {
+  return levelSingleton;
+}

package/src/log-writer-impl.ts

@@ -0,0 +1,58 @@
+export class LogWriterStream {
+  readonly _out: WritableStream<Uint8Array>;
+  readonly _toFlush: (() => Promise<void>)[] = [];
+
+  constructor(out: WritableStream<Uint8Array>) {
+    this._out = out;
+  }
+
+  write(encoded: Uint8Array): void {
+    const my = async (): Promise<void> => {
+      // const val = Math.random();
+      // console.log(">>>My:", val)
+      try {
+        const writer = this._out.getWriter();
+        await writer.ready;
+        await writer.write(encoded);
+        await writer.releaseLock();
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error("Chunk error:", err);
+      }
+      // console.log("<<<My:", val)
+    };
+    this._toFlush.push(my);
+    this._flush();
+  }
+
+  _flushIsRunning = false;
+  _flushDoneFns: (() => void)[] = [];
+  _flush(toFlush: (() => Promise<void>)[] | undefined = undefined, done?: () => void): void {
+    if (done) {
+      this._flushDoneFns.push(done);
+    }
+
+    if (this._toFlush.length == 0) {
+      // console.log("Flush is stopped", this._toFlush.length)
+      this._flushIsRunning = false;
+      this._flushDoneFns.forEach((fn) => fn());
+      this._flushDoneFns = [];
+      return;
+    }
+
+    if (!toFlush && this._toFlush.length == 1 && !this._flushIsRunning) {
+      this._flushIsRunning = true;
+      // console.log("Flush is started", this._toFlush.length)
+    } else if (!toFlush) {
+      // console.log("flush queue check but is running", this._toFlush.length)
+      return;
+    }
+
+    // console.log(">>>Msg:", this._toFlush.length)
+    const my = this._toFlush.shift();
+    my?.().finally(() => {
+      // console.log("<<<Msg:", this._toFlush.length)
+      this._flush(this._toFlush);
+    });
+  }
+}