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

package/src/cli/patch-version-cmd.ts

@@ -0,0 +1,289 @@
+import * as ts from "typescript";
+import { command, option, restPositionals, string } from "cmd-ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as process from "node:process";
+import { $, cd, glob } from "zx";
+
+// Custom compiler host
+function createCompilerHost(options: ts.CompilerOptions, version: string): ts.CompilerHost {
+  const host = ts.createCompilerHost(options);
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const myGetSourceFile = host.getSourceFile;
+
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile): ts.SourceFile => {
+    const sourceFile = myGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+
+    // Patch version.ts during compilation
+    if (fileName.endsWith("version.ts") && sourceFile) {
+      const newText = `export const VERSION: string = "${version}";`;
+      return ts.createSourceFile(fileName, newText, languageVersion);
+    }
+
+    return sourceFile;
+  };
+  return host;
+}
+
+function readTSConfig(configPath = "./tsconfig.json"): ts.CompilerOptions {
+  // Read the config file
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+
+  if (configFile.error) {
+    throw new Error(`Error reading tsconfig: ${configFile.error.messageText as string}`);
+  }
+
+  // Parse and resolve the config
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), undefined, configPath);
+
+  if (parsedConfig.errors.length > 0) {
+    const errors = parsedConfig.errors.map((err) => err.messageText as string).join("\n");
+    throw new Error(`Error parsing tsconfig: ${errors}`);
+  }
+
+  return parsedConfig.options; // This is CompilerOptions
+}
+
+function versionFromPackageJson(): string {
+  const packageJson = JSON.parse(fs.readFileSync("package.json").toString()) as { version: string };
+  return packageJson.version;
+}
+
+export function generateVersionTsCmd(): ReturnType<typeof command> {
+  return command({
+    name: "fireproof build cli",
+    description: "helps to build fp",
+    version: "1.0.0",
+    args: {
+      version: option({
+        long: "version",
+        short: "v",
+        defaultValue: () => getVersion(),
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Version to patch in, defaults to reading from package.json.",
+      }),
+      versionFile: option({
+        long: "versionFile",
+        short: "f",
+        defaultValue: () => "src/version.ts",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the file containing the version, defaults to './src/version.ts'.",
+      }),
+      tsconfig: option({
+        long: "tsconfig",
+        short: "t",
+        defaultValue: () => "tsconfig.json",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the tsconfig.json file, defaults to './tsconfig.json'.",
+      }),
+    },
+    handler: (args) => {
+      const options = readTSConfig(args.tsconfig);
+      const host = createCompilerHost(options, args.version);
+      const program = ts.createProgram([args.versionFile], options, host);
+      program.emit();
+    },
+  });
+}
+
+function getVersion(iversion?: string): string {
+  const ghref = iversion || process.env.GITHUB_REF || versionFromPackageJson() || "a/v0.0.0-smoke";
+  const lastPart = ghref.split("/").slice(-1)[0];
+  let version = "0.0.0-smoke-ci";
+  if (lastPart.match(/^v/)) {
+    version = lastPart.replace(/^v/, "");
+  }
+  return version;
+}
+
+export function patchVersionCmd(): ReturnType<typeof command> {
+  return command({
+    name: "patch-version",
+    description: "patch version in package.json and deno.json",
+    version: "1.0.0",
+    args: {
+      version: option({
+        long: "version",
+        short: "v",
+        defaultValue: () => getVersion(),
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the file containing the version, defaults to './package.json'.",
+      }),
+      files: restPositionals({
+        type: string,
+        displayName: "packageJsonFiles",
+        description: "package.json files to process",
+      }),
+    },
+    handler: (args) => {
+      const version = getVersion(args.version);
+      for (const fileToPatch of args.files) {
+        // eslint-disable-next-line no-console
+        console.log(`Patch ${fileToPatch} version to ${version}(${process.env.GITHUB_REF})`);
+        const packageJson = JSON.parse(fs.readFileSync(fileToPatch).toString()) as { version: string };
+        packageJson.version = version;
+        fs.writeFileSync(fileToPatch, JSON.stringify(packageJson, undefined, 2) + "\n");
+      }
+    },
+  });
+}
+
+// node ./setup-jsr-json.cjs ./pubdir/deno.json
+function setupDenoJson(packageJsonFile: string, jsrJsonFile: string): void {
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonFile).toString()) as { dependencies: Record<string, string> };
+  const jsrJson = JSON.parse(fs.readFileSync(jsrJsonFile).toString()) as { imports: Record<string, string> };
+  jsrJson.imports = Object.fromEntries(
+    Array.from(Object.entries(packageJson.dependencies)).map(([k, v]) => [k, `npm:${k}@${v.replace(/^npm:/, "")}`]),
+  );
+  fs.writeFileSync(jsrJsonFile, JSON.stringify(jsrJson, undefined, 2) + "\n");
+}
+
+export function setUpDenoJsonCmd(): ReturnType<typeof command> {
+  return command({
+    name: "setup-deno-json",
+    description: "setup deno.json",
+    version: "1.0.0",
+    args: {
+      packageJson: option({
+        long: "packageJson",
+        short: "p",
+        defaultValue: () => "package.json",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the package.json file, defaults to './package.json'.",
+      }),
+      jsrJson: option({
+        long: "jsrJson",
+        short: "j",
+        defaultValue: () => "deno.json",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the deno.json file, defaults to './deno.json'.",
+      }),
+    },
+    handler: (args) => {
+      // eslint-disable-next-line no-console
+      console.log(`Setup deno.json ${args.jsrJson} from ${args.packageJson}`);
+      setupDenoJson(args.packageJson, args.jsrJson);
+    },
+  });
+}
+
+export async function preparePubdir(pubdir: string, version: string): Promise<void> {
+  // Set shell options equivalent to 'set -ex'
+  $.verbose = true;
+
+  // Build if not in CI
+  if (process.env.IN_CI !== "in_ci") {
+    await $`pnpm run build`;
+  }
+
+  // Clean and create pubdir
+  await $`rm -rf ${pubdir}`;
+  await $`mkdir -p ${pubdir}`;
+
+  // Copy files to pubdir
+  await $`cp -pr ../.gitignore ../README.md ../LICENSE ./dist/ts/ ${pubdir}/`;
+
+  // Copy from dist/pkg
+  cd("dist/pkg");
+  await $`cp -pr . ../../${pubdir}/`;
+  cd("../..");
+
+  // Copy from src
+  cd("src");
+  await $`cp -pr . ../${pubdir}/src/`;
+  cd("..");
+
+  // Rename .js files to .cjs in pubdir/cjs
+  const jsFiles = await glob(`${pubdir}/cjs/**/*.js`);
+  for (const file of jsFiles) {
+    const newFile = file.replace(/\.js$/, ".cjs");
+    await $`mv ${file} ${newFile}`;
+  }
+
+  // Rename .js.map files to .cjs.map in pubdir/cjs
+  const mapFiles = await glob(`${pubdir}/cjs/**/*.js.map`);
+  for (const file of mapFiles) {
+    const newFile = file.replace(/\.js\.map$/, ".cjs.map");
+    await $`mv ${file} ${newFile}`;
+  }
+
+  // Run jscodeshift on .cjs files
+  const cjsFiles = await glob(`${pubdir}/cjs/**/*.cjs`);
+  if (cjsFiles.length > 0) {
+    await $`pnpm exec jscodeshift --parser=babel -t=./to-cjs.js ${cjsFiles}`;
+  }
+
+  // Copy package.json
+  await $`cp package.json ${pubdir}/`;
+
+  // Clean up test files in pubdir/src
+  cd(`${pubdir}/src`);
+  await $`rm -f test/test-exit-handler.* ./utils/stream-test-helper.ts`.catch(() => {
+    // Ignore errors if files don't exist
+  });
+  cd("../..");
+
+  // Remove __screenshots__ directories
+  const screenshotDirs = await glob(`${pubdir}/src/**/__screenshots__`);
+  for (const dir of screenshotDirs) {
+    await $`rm -rf ${dir}`;
+  }
+
+  // Remove test files
+  const testFiles = await glob(`${pubdir}/src/**/*.test.ts`);
+  for (const file of testFiles) {
+    await $`rm -f ${file}`;
+  }
+
+  // Copy deno.json
+  await $`cp ./deno.json ./${pubdir}/`;
+
+  // Patch version in package.json and deno.json
+  await patchVersionCmd().handler({ version, files: [`${pubdir}/package.json`, `${pubdir}/deno.json`] });
+  // await $`sh src/cli/run.sh patchVersion ./pubdir/package.json ./pubdir/deno.json`;
+
+  // Setup JSR JSON
+  await setUpDenoJsonCmd().handler({ packageJson: `${pubdir}/package.json`, jsrJson: `${pubdir}/deno.json` });
+  // await $`node ./setup-jsr-json.cjs ./pubdir/deno.json`;
+
+  // Pack and publish
+  cd("pubdir");
+  await $`pnpm pack`;
+  await $`deno publish --dry-run --unstable-sloppy-imports --allow-dirty`;
+}
+
+export function preparePubdirCmd(): ReturnType<typeof command> {
+  return command({
+    name: "prepare-pubdir",
+    description: "prepare pubdir",
+    version: "1.0.0",
+    args: {
+      pubdir: option({
+        long: "pubdir",
+        short: "p",
+        defaultValue: () => "pubdir",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the pubdir, defaults to './pubdir'.",
+      }),
+      version: option({
+        long: "version",
+        short: "v",
+        defaultValue: () => getVersion(),
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Version to patch in, defaults to reading from package.json.",
+      }),
+    },
+    handler: async (args) => {
+      await preparePubdir(args.pubdir, args.version);
+    },
+  });
+}

package/src/cli/run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec pnpm exec tsx $(dirname $0)/main.ts $@

package/src/coerce-binary.ts

@@ -0,0 +1,39 @@
+export type CoerceBinaryInput = string | ArrayBufferLike | ArrayBufferView | Uint8Array; // | SharedArrayBuffer
+
+export async function top_uint8(input: CoerceBinaryInput | Blob): Promise<Uint8Array> {
+  if (input instanceof Blob) {
+    return new Uint8Array(await input.arrayBuffer());
+  }
+  return to_uint8(input);
+}
+
+export function to_uint8(input: CoerceBinaryInput, encoder?: TextEncoder): Uint8Array {
+  if (typeof input === "string") {
+    return (encoder ?? new TextEncoder()).encode(input);
+  }
+  if (input instanceof ArrayBuffer /* || input instanceof SharedArrayBuffer */) {
+    return new Uint8Array(input);
+  }
+
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  // not nice but we make the cloudflare types happy
+  return new Uint8Array(input as unknown as ArrayBufferLike);
+}
+
+export function to_blob(input: CoerceBinaryInput | Blob, encoder?: TextEncoder): Blob {
+  if (input instanceof Blob) {
+    return input;
+  }
+  return new Blob([to_uint8(input, encoder)]);
+}
+
+export function to_arraybuf(input: CoerceBinaryInput, encoder?: TextEncoder): ArrayBuffer {
+  if (input instanceof ArrayBuffer) {
+    return input;
+  }
+  const u8 = to_uint8(input, encoder);
+  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength) as ArrayBuffer;
+  // return to_uint8(input).buffer; //  as ArrayBuffer;
+}

package/src/crypto.ts

@@ -1,3 +1,9 @@
+export interface CTRsaOtherPrimesInfo {
+  d?: string;
+  r?: string;
+  t?: string;
+}
+
 export interface CTJsonWebKey {
   alg?: string;
   crv?: string;
@@ -10,7 +16,7 @@ export interface CTJsonWebKey {
   key_ops?: string[];
   kty?: string;
   n?: string;
-  oth?: RsaOtherPrimesInfo[];
+  oth?: CTRsaOtherPrimesInfo[];
   p?: string;
   q?: string;
   qi?: string;
@@ -80,7 +86,7 @@ export interface CTArrayBufferView {
   byteOffset: number;
 }
 
-export type CTBufferSource = CTArrayBufferView | ArrayBuffer;
+export type CTBufferSource = CTArrayBufferView | ArrayBuffer | Uint8Array;
 
 export interface CryptoRuntime {
   importKey(
@@ -99,26 +105,60 @@ export interface CryptoRuntime {
   randomBytes(size: number): Uint8Array;
 }
 
-function randomBytes(size: number): Uint8Array {
-  const bytes = new Uint8Array(size);
-  if (size > 0) {
-    crypto.getRandomValues(bytes);
-  }
-  return bytes;
+function randomBytes(crypto: typeof globalThis.crypto): CryptoRuntime["randomBytes"] {
+  return (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));
+function digestSHA256(crypto: typeof globalThis.crypto): (data: Uint8Array) => Promise<ArrayBuffer> {
+  return (data: Uint8Array): Promise<ArrayBuffer> => {
+    return crypto.subtle.digest("SHA-256", data);
+  };
 }
 
 export function toCryptoRuntime(cryptoOpts: Partial<CryptoRuntime> = {}): CryptoRuntime {
+  let crypto: typeof globalThis.crypto;
+  if (!globalThis.crypto || !globalThis.crypto.subtle) {
+    crypto = {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      getRandomValues: globalThis.crypto.getRandomValues.bind(globalThis.crypto),
+      subtle: {
+        importKey: (): Promise<CTCryptoKey> => {
+          throw new Error("crypto.subtle.importKey not available");
+        },
+        exportKey: () => {
+          throw new Error("crypto.subtle.exportKey not available");
+        },
+        encrypt: (): Promise<ArrayBuffer> => {
+          throw new Error("crypto.subtle.encrypt not available");
+        },
+        decrypt: (): Promise<ArrayBuffer> => {
+          throw new Error("crypto.subtle.decrypt not available");
+        },
+        digest: (): Promise<ArrayBuffer> => {
+          throw new Error("crypto.subtle.digest not available");
+        },
+      },
+    } as unknown as typeof globalThis.crypto;
+  } else {
+    crypto = globalThis.crypto;
+  }
   const runtime = {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     exportKey: cryptoOpts.exportKey || crypto.subtle.exportKey.bind(crypto.subtle),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
-    randomBytes: cryptoOpts.randomBytes || randomBytes,
-    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256,
+    randomBytes: cryptoOpts.randomBytes || randomBytes(crypto),
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256(crypto),
   };
   // console.log("cryptoOpts", cryptoOpts, opts)
   return runtime;

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

@@ -0,0 +1,41 @@
+/// <reference types="deno" />
+
+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 DenoRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+  }
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return Deno.args;
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return Deno.stdout.writable;
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return Deno.stderr.writable;
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function DenoBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new DenoRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}

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

@@ -0,0 +1,57 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+
+interface DenoEnv {
+  get: (key: string) => string | undefined;
+  toObject: () => Record<string, string>;
+  set: (key: string, value: string) => void;
+  has: (key: string) => boolean;
+  delete: (key: string) => void;
+}
+
+const once = new ResolveOnce<DenoEnvActions>();
+export class DenoEnvActions implements EnvActions {
+  readonly #deno = globalThis as unknown as {
+    Deno: {
+      env: DenoEnv;
+    };
+  };
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new DenoEnvActions(opts));
+  }
+
+  get _env(): DenoEnv {
+    return this.#deno.Deno.env;
+  }
+
+  readonly opts: Partial<EnvFactoryOpts>;
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  register(env: Env): Env {
+    for (const key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
+    }
+    return env;
+  }
+  active(): boolean {
+    return runtimeFn().isDeno;
+  }
+  keys(): string[] {
+    return Object.keys(this._env.toObject());
+  }
+  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);
+  }
+}

package/src/deno/deno-file-service.ts

@@ -0,0 +1,92 @@
+import * as path from "node:path";
+import type { FileService, NamedWritableStream } from "../file-service.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
+  cwd(): string;
+  readFile(fname: string): Promise<Uint8Array>;
+  mkdir(base: string, options: { recursive: boolean }): Promise<void>;
+  open(fname: string, options: { write: boolean; create: boolean; truncate: boolean }): Promise<WritableStream<Uint8Array>>;
+};
+
+export class DenoFileService implements FileService {
+  readonly baseDir: string;
+  readonly txtEnde: TxtEnDecoder;
+  constructor(baseDir: string = Deno.cwd(), txtEnde: TxtEnDecoder = TxtEnDecoderSingleton()) {
+    this.baseDir = this.abs(baseDir);
+    this.txtEnde = txtEnde;
+  }
+
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+
+  async readFileString(fname: string): Promise<string> {
+    return this.txtEnde.decode(await Deno.readFile(fname));
+  }
+
+  dirname(fname: string): string {
+    return path.dirname(fname);
+  }
+  basename(fname: string): string {
+    return path.basename(fname);
+  }
+
+  join(...paths: string[]): string {
+    return path.join(...paths);
+  }
+
+  relative(from: string, to?: string): string {
+    if (to === undefined) {
+      to = from;
+      from = Deno.cwd();
+    }
+    const ret = path.relative(from, to);
+    // console.log('relative:'+ from + " -> " + to +   "= " + ret);
+    return ret;
+  }
+
+  abs(fname: string): string {
+    if (path.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = Deno.cwd();
+      return path.resolve(cwd, fname);
+    }
+  }
+
+  isAbsolute(fname: string): boolean {
+    return path.isAbsolute(fname);
+  }
+
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): Promise<void> {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+
+  async create(fname: string): Promise<NamedWritableStream> {
+    let oName = fname;
+    if (!path.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+
+    const base = path.dirname(oName);
+    await Deno.mkdir(base, { recursive: true });
+    const out = await Deno.open(oName, {
+      write: true,
+      create: true,
+      truncate: true,
+    });
+    return {
+      name: oName,
+      stream: out,
+    };
+  }
+}