@naesofteak/naeso 0.0.0-stage → 1.0.0

package/src/core/package-downloader.js

@@ -0,0 +1,284 @@
+const fs = require("fs");
+const path = require("path");
+
+const {
+  resolvePackage
+} = require("./package-resolver");
+
+const {
+  downloadFile
+} = require("./downloader");
+
+const {
+  calculateSHA256
+} = require("./checksum");
+
+const {
+  ensurePackageCache,
+  getCachedFile
+} = require("./cache");
+
+async function verifyArtifact(
+  artifact,
+  archivePath,
+  packageName
+) {
+  /*
+   * If the registry provides an official SHA-256 URL,
+   * download and verify it.
+   */
+  if (artifact.sha256Url) {
+    const archiveName =
+      path.basename(
+        new URL(artifact.url).pathname
+      );
+
+    const checksumName =
+      `${archiveName}.sha256`;
+
+    const checksumPath =
+      getCachedFile(
+        packageName,
+        checksumName
+      );
+
+    if (fs.existsSync(checksumPath)) {
+      console.log(
+        `Checksum file already exists: ${checksumPath}`
+      );
+    } else {
+      console.log(
+        "Downloading official SHA-256 checksum..."
+      );
+
+      await downloadFile(
+        artifact.sha256Url,
+        checksumPath
+      );
+
+      console.log(
+        `Downloaded: ${checksumPath}`
+      );
+    }
+
+    const checksumText =
+      fs.readFileSync(
+        checksumPath,
+        "utf8"
+      ).trim();
+
+    const expectedHash =
+      checksumText
+        .split(/\s+/)[0]
+        .toLowerCase();
+
+    if (!/^[a-f0-9]{64}$/.test(expectedHash)) {
+      throw new Error(
+        `Invalid SHA-256 checksum for ${artifact.name}.`
+      );
+    }
+
+    console.log(
+      `Expected SHA-256: ${expectedHash}`
+    );
+
+    console.log(
+      "Calculating downloaded archive SHA-256..."
+    );
+
+    const actualHash =
+      (
+        await calculateSHA256(
+          archivePath
+        )
+      ).toLowerCase();
+
+    console.log(
+      `Actual SHA-256:   ${actualHash}`
+    );
+
+    if (actualHash !== expectedHash) {
+      fs.unlinkSync(archivePath);
+
+      throw new Error(
+        `${artifact.name} failed SHA-256 verification.`
+      );
+    }
+
+    console.log(
+      `${artifact.name} SHA-256 verification PASSED.`
+    );
+
+    return {
+      verified: true,
+      checksum: expectedHash
+    };
+  }
+
+  /*
+   * No official checksum URL is registered yet.
+   *
+   * We still calculate the local SHA-256 so that the
+   * artifact gets a deterministic fingerprint.
+   */
+  console.log(
+    `No official SHA-256 URL registered for ${artifact.name}.`
+  );
+
+  const actualHash =
+    (
+      await calculateSHA256(
+        archivePath
+      )
+    ).toLowerCase();
+
+  console.log(
+    `SHA-256: ${actualHash}`
+  );
+
+  return {
+    verified: false,
+    checksum: actualHash
+  };
+}
+
+async function downloadArtifact(
+  packageName,
+  artifact
+) {
+  const cacheDirectory =
+    ensurePackageCache(
+      packageName
+    );
+
+  const archiveName =
+    path.basename(
+      new URL(artifact.url).pathname
+    );
+
+  const archivePath =
+    getCachedFile(
+      packageName,
+      archiveName
+    );
+
+  console.log("");
+  console.log(
+    `Artifact: ${artifact.name}`
+  );
+  console.log(
+    `Type:     ${artifact.type}`
+  );
+  console.log(
+    `Version:  ${artifact.version}`
+  );
+  console.log(
+    `URL:      ${artifact.url}`
+  );
+  console.log("");
+
+  if (fs.existsSync(archivePath)) {
+    console.log(
+      `Archive already exists: ${archivePath}`
+    );
+  } else {
+    console.log(
+      `Downloading ${archiveName}...`
+    );
+
+    await downloadFile(
+      artifact.url,
+      archivePath
+    );
+
+    console.log(
+      `Downloaded: ${archivePath}`
+    );
+  }
+
+  const verification =
+    await verifyArtifact(
+      artifact,
+      archivePath,
+      packageName
+    );
+
+  return {
+    ...artifact,
+    archive: archivePath,
+    checksum: verification.checksum,
+    verified: verification.verified
+  };
+}
+
+async function downloadPackage(
+  packageName,
+  requestedVersion = null
+) {
+  const resolved =
+    resolvePackage(
+      packageName,
+      requestedVersion
+    );
+
+  const {
+    package: pkg,
+    version,
+    target,
+    artifacts
+  } = resolved;
+
+  console.log("");
+  console.log(
+    "Naeso Package Download"
+  );
+  console.log(
+    "----------------------"
+  );
+  console.log(
+    `Package: ${pkg.name}`
+  );
+  console.log(
+    `Version: ${version}`
+  );
+  console.log(
+    `Target:  ${target}`
+  );
+  console.log("");
+
+  const downloaded = {};
+
+  for (
+    const [artifactName, artifact]
+    of Object.entries(artifacts)
+  ) {
+    const artifactWithName = {
+      ...artifact,
+      name: artifactName
+    };
+
+    downloaded[artifactName] =
+      await downloadArtifact(
+        packageName,
+        artifactWithName
+      );
+  }
+
+  console.log("");
+  console.log(
+    "All MongoDB artifacts downloaded."
+  );
+  console.log("");
+
+  return {
+    package: pkg.name,
+    version,
+    target,
+    artifacts: downloaded
+  };
+}
+
+module.exports = {
+  downloadPackage,
+  downloadArtifact
+};

package/src/core/package-resolver.js

@@ -0,0 +1,125 @@
+const { getPackage } = require("./registry");
+const { getTarget } = require("./target");
+
+const {
+  getLatestVersion,
+  getVersionConfig,
+  isPackageSupported
+} = require("./compatibility");
+
+function resolvePackage(packageName, requestedVersion = null) {
+  const pkg = getPackage(packageName);
+
+  if (!pkg) {
+    throw new Error(
+      `Package '${packageName}' not found.`
+    );
+  }
+
+  const target = getTarget();
+
+  const version =
+    requestedVersion ||
+    getLatestVersion(pkg);
+
+  if (!version) {
+    throw new Error(
+      `No versions available for '${packageName}'.`
+    );
+  }
+
+  const versionConfig =
+    getVersionConfig(pkg, version);
+
+  if (!versionConfig) {
+    throw new Error(
+      `Version '${version}' not found for '${packageName}'.`
+    );
+  }
+
+  if (
+    !isPackageSupported(
+      pkg,
+      target.target,
+      version
+    )
+  ) {
+    throw new Error(
+      `${packageName} ${version} does not support ${target.target}.`
+    );
+  }
+
+  const targetConfig =
+    versionConfig.config.targets[target.target];
+
+  if (!targetConfig) {
+    throw new Error(
+      `${packageName} ${version} does not support ${target.target}.`
+    );
+  }
+
+  /*
+   * New multi-artifact package format
+   */
+  if (targetConfig.artifacts) {
+    const artifacts = {};
+
+    for (
+      const [artifactName, artifactConfig]
+      of Object.entries(targetConfig.artifacts)
+    ) {
+      if (!artifactConfig.url) {
+        throw new Error(
+          `Artifact '${artifactName}' has no download URL.`
+        );
+      }
+
+      artifacts[artifactName] = {
+        name: artifactName,
+        type: artifactConfig.type,
+        version: artifactConfig.version || version,
+        url: artifactConfig.url,
+        sha256Url:
+          artifactConfig.sha256Url || null
+      };
+    }
+
+    return {
+      package: pkg,
+      version,
+      target: target.target,
+      artifacts
+    };
+  }
+
+  /*
+   * Backward compatibility with the old
+   * single-artifact package format.
+   */
+  if (targetConfig.url) {
+    return {
+      package: pkg,
+      version,
+      target: target.target,
+
+      artifacts: {
+        default: {
+          name: "default",
+          type: "tarball",
+          version,
+          url: targetConfig.url,
+          sha256Url:
+            targetConfig.sha256Url || null
+        }
+      }
+    };
+  }
+
+  throw new Error(
+    `No artifacts defined for ${packageName} ${version} on ${target.target}.`
+  );
+}
+
+module.exports = {
+  resolvePackage
+};

package/src/core/platform.js

@@ -0,0 +1,41 @@
+const os = require("os");
+const { execSync } = require("child_process");
+
+function getPlatform() {
+  return process.platform;
+}
+
+function getArchitecture() {
+  return process.arch;
+}
+
+function getMacOSVersion() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+
+  try {
+    return execSync("sw_vers -productVersion")
+      .toString()
+      .trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+function getPlatformInfo() {
+  return {
+    platform: getPlatform(),
+    architecture: getArchitecture(),
+    macosVersion: getMacOSVersion(),
+    hostname: os.hostname(),
+    cpuCount: os.cpus().length
+  };
+}
+
+module.exports = {
+  getPlatform,
+  getArchitecture,
+  getMacOSVersion,
+  getPlatformInfo
+};

package/src/core/registry.js

@@ -0,0 +1,70 @@
+const fs = require("fs");
+const path = require("path");
+
+const REGISTRY_PATH = path.join(
+  __dirname,
+  "..",
+  "registry",
+  "packages"
+);
+
+function getPackagePath(packageName) {
+  return path.join(
+    REGISTRY_PATH,
+    packageName,
+    "package.json"
+  );
+}
+
+function getPackage(packageName) {
+  const packagePath = getPackagePath(packageName);
+
+  if (!fs.existsSync(packagePath)) {
+    return null;
+  }
+
+  try {
+    const data = fs.readFileSync(packagePath, "utf8");
+    return JSON.parse(data);
+  } catch (error) {
+    throw new Error(
+      `Invalid package definition: ${packageName}`
+    );
+  }
+}
+
+function packageExists(packageName) {
+  return fs.existsSync(getPackagePath(packageName));
+}
+
+function listPackages() {
+  if (!fs.existsSync(REGISTRY_PATH)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(REGISTRY_PATH, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+}
+
+function searchPackages(keyword) {
+  const packages = listPackages();
+
+  if (!keyword) {
+    return packages;
+  }
+
+  const search = keyword.toLowerCase();
+
+  return packages.filter((packageName) =>
+    packageName.toLowerCase().includes(search)
+  );
+}
+
+module.exports = {
+  getPackage,
+  packageExists,
+  listPackages,
+  searchPackages
+};

package/src/core/target.js

@@ -0,0 +1,56 @@
+const {
+  getPlatformInfo
+} = require("./platform");
+
+function getTarget() {
+  const system = getPlatformInfo();
+
+  let platform;
+
+  switch (system.platform) {
+    case "darwin":
+      platform = "macos";
+      break;
+
+    case "linux":
+      platform = "linux";
+      break;
+
+    case "win32":
+      platform = "windows";
+      break;
+
+    default:
+      platform = system.platform;
+  }
+
+  let architecture;
+
+  switch (system.architecture) {
+    case "x64":
+      architecture = "x86_64";
+      break;
+
+    case "arm64":
+      architecture = "arm64";
+      break;
+
+    case "ia32":
+      architecture = "x86";
+      break;
+
+    default:
+      architecture = system.architecture;
+  }
+
+  return {
+    platform,
+    architecture,
+    target: `${platform}-${architecture}`,
+    version: system.macosVersion
+  };
+}
+
+module.exports = {
+  getTarget
+};