@cparra/apex-reflection 2.22.0 → 2.23.1

package/README.md

@@ -42,13 +42,6 @@ body was not parsed successfully, with a message indicating where the error occu
 Even though this library is exposed as a Node.js library, the project's source code is written in Dart. The source can
 be found in the `lib/src` directory.
 
-The Dart source code is transpiled to JS by `dart2js` through the default [grinder](https://pub.dev/packages/grinder)
-workflow within `tool/grind.dart`.
-
-To generate the JS files first set up `grinder` locally by following that package's instructions through its pub.dev
-listing, and then you can simply run `grind`. That build takes care of combining the output with `preamble/preamble.js`
-to achieve compatibility with Node.js. The resulting file is `js/apex-reflection-node/out.js`.
-
 ### Tests
 
 Both the Dart source code and the JS output must be tested.

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 export declare function reflect(declarationBody: string): ReflectionResult;
-export declare function reflectAsync(declarationBody: string): Promise<ReflectionResult>;
 export declare function reflectTrigger(declarationBody: string): TriggerReflectionResult;
-export declare function reflectTriggerAsync(declarationBody: string): Promise<TriggerReflectionResult>;
 export interface ParamAnnotation {
     bodyLines: string[];
     paramName: string;

package/dist/index.js

@@ -1,25 +1,82 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reflectTriggerAsync = exports.reflectTrigger = exports.reflectAsync = exports.reflect = void 0;
-require("./out.js");
+exports.reflectTrigger = exports.reflect = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+function resolveNativeBinaryPath() {
+    const platform = process.platform;
+    const arch = process.arch;
+    let folderName;
+    if (platform === "darwin" && arch === "arm64") {
+        folderName = "darwin-arm64";
+    }
+    else if (platform === "darwin" && arch === "x64") {
+        folderName = "darwin-x64";
+    }
+    else if (platform === "linux" && arch === "x64") {
+        folderName = "linux-x64";
+    }
+    else if (platform === "win32" && arch === "x64") {
+        folderName = "windows-x64";
+    }
+    else {
+        throw new Error(`Unsupported platform/arch combination: ${platform}/${arch}`);
+    }
+    const fileName = platform === "win32" ? "apex-reflection.exe" : "apex-reflection";
+    // At runtime, this file is `dist/index.js`, so `__dirname` points to `dist/`.
+    // postinstall installs to: dist/native/<platform-arch>/<fileName>
+    const downloadedPath = path_1.default.join(__dirname, "native", folderName, fileName);
+    // dev flow builds to: dist/native/<platform-arch>/<fileName>
+    // (same place), but keep this explicit so we can evolve paths later.
+    const devBuiltPath = downloadedPath;
+    if (fs_1.default.existsSync(downloadedPath)) {
+        return downloadedPath;
+    }
+    if (fs_1.default.existsSync(devBuiltPath)) {
+        return devBuiltPath;
+    }
+    throw new Error(`Native binary not found. Expected one of:\n- ${downloadedPath}\n- ${devBuiltPath}\n\nIf you just installed this package, ensure postinstall succeeded.\nIf you're developing locally, run the dev build to create the host binary.`);
+}
+function reflectFor(type, declarationBody) {
+    const binaryPath = resolveNativeBinaryPath();
+    const result = (0, child_process_1.spawnSync)(binaryPath, [`--type=${type}`], {
+        input: declarationBody,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024 * 50,
+    });
+    if (result.error) {
+        throw new Error(`apex-reflection native binary failed to start. error:\n${String(result.error)}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`apex-reflection native binary failed (code=${result.status}). stderr:\n${result.stderr ?? ""}`);
+    }
+    const stdout = (result.stdout ?? "").toString().trim();
+    if (!stdout) {
+        throw new Error("apex-reflection native binary produced no output on stdout.");
+    }
+    return stdout;
+}
 function reflect(declarationBody) {
-    // @ts-expect-error "reflect" is added to self by the "out" module
-    return JSON.parse(self.reflect(declarationBody));
+    const stdout = reflectFor("reflectType", declarationBody);
+    try {
+        return JSON.parse(stdout);
+    }
+    catch (e) {
+        throw new Error(`apex-reflection native binary output was not valid JSON.\nstdout:\n${stdout}\nerror: ${String(e)}`);
+    }
 }
 exports.reflect = reflect;
-async function reflectAsync(declarationBody) {
-    // @ts-expect-error "reflectAsync" is added to self by the "out" module
-    const result = await self.reflectAsync(declarationBody);
-    return JSON.parse(result);
-}
-exports.reflectAsync = reflectAsync;
 function reflectTrigger(declarationBody) {
-    // @ts-expect-error "reflectTrigger" is added to self by the "out" module
-    return JSON.parse(self.reflectTrigger(declarationBody));
+    const stdout = reflectFor("reflectTrigger", declarationBody);
+    try {
+        return JSON.parse(stdout);
+    }
+    catch (e) {
+        throw new Error(`apex-reflection native binary output was not valid JSON.\nstdout:\n${stdout}\nerror: ${String(e)}`);
+    }
 }
 exports.reflectTrigger = reflectTrigger;
-function reflectTriggerAsync(declarationBody) {
-    // @ts-expect-error "reflectTriggerAsync" is added to self by the "out" module
-    return self.reflectTriggerAsync(declarationBody).then((result) => JSON.parse(result));
-}
-exports.reflectTriggerAsync = reflectTriggerAsync;

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@cparra/apex-reflection",
-  "version": "2.22.0",
+  "version": "2.23.1",
   "description": "Provides tools for reflecting Apex code, the language used in Salesforce development.",
   "main": "dist/index.js",
   "scripts": {
     "clean": "rimraf dist",
     "build": "npm run clean && tsc",
+    "postinstall": "node publish-scripts/postinstall.js",
+    "dev:build": "npm run build && npm run dev:build:native:host && npm run dev:chmod:native:host",
+    "dev:build:native:host": "node scripts/build-natives.js --host",
+    "dev:chmod:native:host": "node scripts/dev-chmod-native-host.js",
+    "dev:version:prerelease": "node scripts/dev-bump-version-prerelease.js",
+    "dev:github:release": "node scripts/dev-github-release.js",
+    "dev:publish": "node scripts/dev-publish.js",
     "test": "jest"
   },
   "keywords": [
@@ -28,6 +35,8 @@
   },
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist/index.js",
+    "dist/index.d.ts",
+    "publish-scripts/postinstall.js"
   ]
 }

package/publish-scripts/postinstall.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script.
+ * - Downloads the correct native binary for the current platform/arch from GitHub Releases
+ * - Stores it inside this package at: dist/native/<platform-arch>/<binaryName>
+ * - Ensures executable permissions on Unix-like systems
+ *
+ * Asset naming convention (GitHub Release assets):
+ *   apex-reflection-<platform>-<arch>[.exe]
+ *
+ * Where:
+ *   platform: darwin | linux | windows
+ *   arch:     x64 | arm64 (darwin supports both; linux/windows only x64 in this setup)
+ *
+ * The GitHub release tag is expected to be:
+ *   v<version>   (version taken from this package's package.json)
+ *
+ * Note:
+ * - To make installs resilient (especially for dev releases), we try multiple possible asset names.
+ */
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const stream = require("stream");
+const { promisify } = require("util");
+
+const pipeline = promisify(stream.pipeline);
+
+const REPO_OWNER = "cesarParra";
+const REPO_NAME = "apex-reflection";
+
+function main() {
+  console.log("[apex-reflection] postinstall: installing native binary...");
+
+  const pkg = readPackageJson();
+  const version = pkg.version;
+  if (!version || typeof version !== "string") {
+    fail("package.json missing a valid `version` field.");
+  }
+
+  const target = resolveTarget(process.platform, process.arch);
+  const tag = `v${version}`;
+
+  const outDir = path.join(
+    __dirname,
+    "..",
+    "dist",
+    "native",
+    target.folderName,
+  );
+  const outPath = path.join(outDir, target.binaryFileName);
+
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const candidateAssetNames = buildCandidateAssetNames(target);
+
+  return downloadFirstAvailableAsset(tag, candidateAssetNames, outPath)
+    .then(({ assetName }) => {
+      if (process.platform !== "win32") {
+        try {
+          fs.chmodSync(outPath, 0o755);
+        } catch (e) {
+          console.warn(
+            `[apex-reflection] postinstall: could not chmod +x ${outPath}: ${stringifyErr(e)}`,
+          );
+        }
+      }
+
+      console.log(
+        `[apex-reflection] postinstall: native binary installed at: ${outPath} (asset: ${assetName})`,
+      );
+    })
+    .catch((err) => {
+      console.error(
+        "[apex-reflection] postinstall: failed to install native binary.",
+      );
+      console.error(`[apex-reflection] postinstall: ${stringifyErr(err)}`);
+      console.error(
+        "[apex-reflection] postinstall: Verify the release assets here:",
+      );
+      console.error(
+        `https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/tag/${tag}`,
+      );
+      process.exit(1);
+    });
+}
+
+function readPackageJson() {
+  const pkgPath = path.join(__dirname, "..", "package.json");
+  const raw = fs.readFileSync(pkgPath, "utf8");
+  return JSON.parse(raw);
+}
+
+function resolveTarget(nodePlatform, nodeArch) {
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  };
+
+  const releasePlatform = platformMap[nodePlatform];
+  if (!releasePlatform) {
+    throw new Error(`Unsupported platform: ${nodePlatform}`);
+  }
+
+  const supportedArch = new Set(["x64", "arm64"]);
+  if (!supportedArch.has(nodeArch)) {
+    throw new Error(`Unsupported architecture: ${nodeArch}`);
+  }
+
+  if (releasePlatform === "linux" && nodeArch !== "x64") {
+    throw new Error(`Unsupported architecture for linux: ${nodeArch}`);
+  }
+  if (releasePlatform === "windows" && nodeArch !== "x64") {
+    throw new Error(`Unsupported architecture for windows: ${nodeArch}`);
+  }
+
+  const folderName = `${releasePlatform}-${nodeArch}`;
+  const exeExt = releasePlatform === "windows" ? ".exe" : "";
+  const binaryFileName = `apex-reflection${exeExt}`;
+
+  return {
+    releasePlatform,
+    releaseArch: nodeArch,
+    folderName,
+    exeExt,
+    binaryFileName,
+  };
+}
+
+function buildCandidateAssetNames(target) {
+  // Primary convention (expected):
+  //   apex-reflection-<platform>-<arch>[.exe]
+  const primary = `apex-reflection-${target.releasePlatform}-${target.releaseArch}${target.exeExt}`;
+
+  // Fallbacks (mainly for dev flows / edge cases):
+  const fallbacks = [];
+
+  // Unsuffixed name (no arch/platform)
+  // - For windows, prefer .exe and then without extension (just in case).
+  if (target.releasePlatform === "windows") {
+    fallbacks.push("apex-reflection.exe");
+    fallbacks.push("apex-reflection");
+  } else {
+    fallbacks.push("apex-reflection");
+  }
+
+  // De-dup while preserving order
+  const seen = new Set();
+  return [primary, ...fallbacks].filter((name) => {
+    if (seen.has(name)) return false;
+    seen.add(name);
+    return true;
+  });
+}
+
+function downloadFirstAvailableAsset(tag, assetNames, destPath) {
+  const base = `https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/download/${tag}/`;
+
+  let lastErr = null;
+
+  // Try sequentially until one downloads successfully
+  return assetNames
+    .reduce(
+      (p, assetName) => {
+        return p.catch((_) => {
+          const url = `${base}${assetName}`;
+          process.stdout.write(
+            `[apex-reflection] postinstall: trying ${url}\n`,
+          );
+          return downloadFile(url, destPath).then(() => ({ assetName }));
+        });
+      },
+      Promise.reject(new Error("No candidate asset attempted yet.")),
+    )
+    .catch((err) => {
+      lastErr = err;
+      const tried = assetNames.map((n) => `${base}${n}`).join("\n");
+      const msg =
+        `Unable to download any matching binary asset for ${process.platform}/${process.arch}.\n` +
+        `Tried:\n${tried}\n` +
+        `Last error: ${stringifyErr(lastErr)}`;
+      throw new Error(msg);
+    });
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const tmpPath = `${destPath}.tmp`;
+
+    try {
+      if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+    } catch (_) {
+      // ignore
+    }
+
+    const request = https.get(url, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        const next = response.headers.location;
+        response.resume();
+        if (!next)
+          return reject(new Error(`Redirect with no location for ${url}`));
+        return downloadFile(next, destPath).then(resolve, reject);
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        return reject(
+          new Error(`HTTP ${response.statusCode} while downloading ${url}`),
+        );
+      }
+
+      const totalSize = Number(response.headers["content-length"] || 0);
+      let downloaded = 0;
+
+      response.on("data", (chunk) => {
+        downloaded += chunk.length;
+        if (totalSize > 0) {
+          const pct = Math.floor((downloaded / totalSize) * 100);
+          process.stdout.write(
+            `\r[apex-reflection] postinstall: downloading... ${pct}%`,
+          );
+        }
+      });
+
+      const file = fs.createWriteStream(tmpPath);
+
+      pipeline(response, file)
+        .then(() => {
+          process.stdout.write("\n");
+          fs.renameSync(tmpPath, destPath);
+          resolve();
+        })
+        .catch((err) => {
+          try {
+            if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+          } catch (_) {
+            // ignore
+          }
+          reject(err);
+        });
+    });
+
+    request.on("error", (err) => {
+      try {
+        if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+      } catch (_) {
+        // ignore
+      }
+      reject(err);
+    });
+  });
+}
+
+function stringifyErr(e) {
+  if (!e) return "unknown error";
+  if (typeof e === "string") return e;
+  if (e && e.message) return e.message;
+  try {
+    return JSON.stringify(e);
+  } catch (_) {
+    return String(e);
+  }
+}
+
+function fail(msg) {
+  console.error(`[apex-reflection] postinstall: ${msg}`);
+  process.exit(1);
+}
+
+Promise.resolve(main());

package/dist/out.d.ts

@@ -1,3 +0,0 @@
-declare var dartNodeIsActuallyNode: boolean;
-declare var self: any;
-declare var url: any;