@temporalio/testing 0.23.0 → 0.23.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/testing",
-  "version": "0.23.0",
+  "version": "0.23.3",
   "description": "Temporal.io SDK Testing sub-package",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
@@ -21,7 +21,7 @@
     "@temporalio/activity": "^0.23.0",
     "@temporalio/client": "^0.23.0",
     "@temporalio/common": "^0.23.0",
-    "@temporalio/worker": "^0.23.0",
+    "@temporalio/worker": "^0.23.2",
     "@types/long": "^4.0.1",
     "abort-controller": "^3.0.0",
     "get-port": "^6.1.2",
@@ -37,10 +37,11 @@
   "homepage": "https://github.com/temporalio/sdk-typescript/tree/main/packages/testing",
   "files": [
     "lib",
-    "generated-protos"
+    "generated-protos",
+    "scripts"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "81ee3fd09c2fd866b31b1dbfabce7ef221e338ea"
+  "gitHead": "2c7ed196ac2379c06419a3c98a7e7eddf1a53b01"
 }

package/scripts/common.mjs

@@ -0,0 +1,18 @@
+import os from 'node:os';
+import { URL, fileURLToPath } from 'node:url';
+
+const platformMapping = { darwin: 'macOS', linux: 'linux', win32: 'windows' };
+const archAlias = { x64: 'amd64', arm64: 'aarch64' };
+
+export const systemPlatform = platformMapping[os.platform()];
+if (!systemPlatform) {
+  throw new Error(`Unsupported platform ${os.platform()}`);
+}
+
+export const systemArch = archAlias[os.arch()];
+if (!systemArch) {
+  throw new Error(`Unsupported architecture ${os.arch()}`);
+}
+
+const ext = systemPlatform === 'windows' ? '.exe' : '';
+export const outputPath = fileURLToPath(new URL(`../test-server${ext}`, import.meta.url));

package/scripts/compile-proto.mjs

@@ -0,0 +1,81 @@
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { promisify } from 'util';
+import dedent from 'dedent';
+import glob from 'glob';
+import { statSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import pbjs from 'protobufjs/cli/pbjs.js';
+import pbts from 'protobufjs/cli/pbts.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const outputDir = resolve(__dirname, '../generated-protos');
+const outputFile = resolve(outputDir, 'index.js');
+const protoBaseDir = resolve(__dirname, '../proto');
+
+const serviceProtoPath = resolve(protoBaseDir, 'temporal/api/testservice/v1/service.proto');
+
+function mtime(path) {
+  try {
+    return statSync(path).mtimeMs;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return 0;
+    }
+    throw err;
+  }
+}
+
+async function compileProtos(protoPath, jsOutputFile, dtsOutputFile, ...args) {
+  console.log(`Creating protobuf JS definitions from ${protoPath}`);
+
+  const pbjsArgs = [
+    ...args,
+    '--wrap',
+    'commonjs',
+    '--target',
+    'static-module',
+    '--force-long',
+    '--no-verify',
+    '--root',
+    '__temporal_testing',
+    '--out',
+    jsOutputFile,
+    protoPath,
+  ];
+  await promisify(pbjs.main)(pbjsArgs);
+
+  console.log(`Creating protobuf TS definitions from ${protoPath}`);
+  await promisify(pbts.main)(['--out', dtsOutputFile, jsOutputFile]);
+
+  // Fix issue where Long is not found in TS definitions (https://github.com/protobufjs/protobuf.js/issues/1533)
+  const pbtsOutput = readFileSync(dtsOutputFile, 'utf8');
+  writeFileSync(
+    dtsOutputFile,
+    dedent`
+  import Long from "long";
+  ${pbtsOutput}
+  `
+  );
+}
+
+async function main() {
+  mkdirSync(outputDir, { recursive: true });
+
+  const protoFiles = glob.sync(resolve(protoBaseDir, '**/*.proto'));
+  const protosMTime = Math.max(...protoFiles.map(mtime));
+  const genMTime = mtime(outputFile);
+
+  if (protosMTime < genMTime) {
+    console.log('Assuming protos are up to date');
+    return;
+  }
+
+  await compileProtos(serviceProtoPath, outputFile, resolve(outputDir, 'index.d.ts'), '--path', resolve(protoBaseDir));
+
+  console.log('Done');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/download-test-server.mjs

@@ -0,0 +1,91 @@
+import stream from 'node:stream';
+import util from 'node:util';
+import zlib from 'node:zlib';
+import fs from 'node:fs';
+import got from 'got';
+import tar from 'tar-stream';
+import unzipper from 'unzipper';
+import { outputPath, systemArch, systemPlatform } from './common.mjs';
+
+try {
+  if (fs.statSync(outputPath).isFile) {
+    console.log('Found existing test server executable', { path: outputPath });
+    process.exit(0);
+  }
+} catch (err) {
+  if (err.code !== 'ENOENT') {
+    throw err;
+  }
+}
+
+const pipeline = util.promisify(stream.pipeline);
+
+const defaultHeaders = {
+  'User-Agent': '@temporalio/testing installer',
+};
+
+const { GITHUB_TOKEN } = process.env;
+
+if (GITHUB_TOKEN) {
+  console.log(`Using GITHUB_TOKEN`);
+  defaultHeaders['Authorization'] = `Bearer ${GITHUB_TOKEN}`;
+}
+
+const latestReleaseRes = await got('https://api.github.com/repos/temporalio/sdk-java/releases/latest', {
+  headers: {
+    ...defaultHeaders,
+    Accept: 'application/vnd.github.v3+json',
+  },
+}).json();
+
+function findTestServerAsset(assets) {
+  for (const asset of assets) {
+    const m = asset.name.match(/^temporal-test-server_[^_]+_([^_]+)_([^.]+)\.(?:zip|tar.gz)$/);
+    if (m) {
+      const [_, assetPlatform, _assetArch] = m;
+      if (assetPlatform === systemPlatform) {
+        // TODO: assetArch === systemArch (no arm builds for test server yet)
+        return asset;
+      }
+    }
+  }
+  throw new Error(`No prebuilt test server for ${systemPlatform}-${systemArch}`);
+}
+
+const asset = findTestServerAsset(latestReleaseRes.assets);
+console.log('Downloading test server', { asset: asset.name, outputPath });
+
+if (asset.content_type === 'application/x-gzip' || asset.content_type === 'application/x-gtar') {
+  const extract = tar.extract();
+  extract.on('entry', (_headers, stream, next) => {
+    stream.pipe(fs.createWriteStream(outputPath));
+    next();
+  });
+  await pipeline(
+    got.stream(asset.browser_download_url, {
+      headers: {
+        ...defaultHeaders,
+      },
+    }),
+    zlib.createGunzip(),
+    extract
+  );
+  await fs.promises.chmod(outputPath, 0o755);
+} else if (asset.content_type === 'application/zip') {
+  got
+    .stream(asset.browser_download_url, {
+      headers: {
+        ...defaultHeaders,
+      },
+    })
+    .pipe(unzipper.Parse())
+    .on('entry', (entry) => {
+      if (entry.type === 'File') {
+        entry.pipe(fs.createWriteStream(outputPath));
+      } else {
+        entry.autodrain();
+      }
+    });
+} else {
+  throw new Error(`Unexpected content type for Test server download: ${asset.content_type}`);
+}