@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-MMAZFJDG.js

@@ -0,0 +1,91 @@
+import {
+  validateProductConfig
+} from "./chunk-LZJMVPYW.js";
+import {
+  NonRetryableError
+} from "./chunk-ZOC4GITL.js";
+
+// src/manifest/config-load.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { pathToFileURL } from "url";
+var CANDIDATE_FILENAMES = [
+  "bulletin-deploy.config.ts",
+  "bulletin-deploy.config.js",
+  "bulletin-deploy.config.mjs"
+];
+async function loadProductConfig(options = {}) {
+  const sourcePath = await resolveConfigPath(options);
+  const mod = await importConfig(sourcePath);
+  const candidate = pickDefault(mod);
+  const result = validateProductConfig(candidate);
+  if (!result.ok) {
+    throw new NonRetryableError(
+      `Invalid product config at ${sourcePath}:
+  - ${result.errors.join("\n  - ")}`
+    );
+  }
+  return { config: result.value, sourcePath };
+}
+async function tryLoadProductConfig(options = {}) {
+  try {
+    return await loadProductConfig(options);
+  } catch (err) {
+    if (err instanceof NonRetryableError && /No product config found/.test(err.message)) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function resolveConfigPath(options) {
+  if (options.path) {
+    const resolved = path.resolve(options.path);
+    if (!await fileExists(resolved)) {
+      throw new NonRetryableError(`Product config not found at ${resolved}`);
+    }
+    return resolved;
+  }
+  const start = path.resolve(options.cwd ?? process.cwd());
+  let dir = start;
+  while (true) {
+    for (const name of CANDIDATE_FILENAMES) {
+      const candidate = path.join(dir, name);
+      if (await fileExists(candidate)) return candidate;
+    }
+    if (!options.walkUp) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const where = options.walkUp ? `${start} (walking up)` : start;
+  throw new NonRetryableError(
+    `No product config found in ${where}. Looked for: ${CANDIDATE_FILENAMES.join(", ")}.`
+  );
+}
+async function fileExists(p) {
+  try {
+    const stat2 = await fs.stat(p);
+    return stat2.isFile();
+  } catch {
+    return false;
+  }
+}
+async function importConfig(sourcePath) {
+  if (sourcePath.endsWith(".ts")) {
+    const { createJiti } = await import("jiti");
+    const jiti = createJiti(import.meta.url, { interopDefault: false });
+    return jiti.import(sourcePath);
+  }
+  return import(pathToFileURL(sourcePath).href);
+}
+function pickDefault(mod) {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    return mod.default;
+  }
+  return mod;
+}
+
+export {
+  loadProductConfig,
+  tryLoadProductConfig
+};

package/dist/chunk-NF2FL4ZO.js

@@ -0,0 +1,164 @@
+import {
+  pessimisticSizePreflight
+} from "./chunk-RI3ZLNPN.js";
+import {
+  encodeContenthash,
+  resolveDotnsConnectOptions,
+  storeDirectory,
+  storeFile
+} from "./chunk-P6CHOMN3.js";
+import {
+  DotNS
+} from "./chunk-DNXH4QTI.js";
+import {
+  getPopSelfServeConfig,
+  loadEnvironments,
+  resolveEndpoints
+} from "./chunk-OITUIM2E.js";
+import {
+  NonRetryableError
+} from "./chunk-ZOC4GITL.js";
+
+// src/manifest/publish.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function publishManifest(opts) {
+  const { config, sourcePath } = opts.loaded;
+  if (config.domain !== opts.domain) {
+    throw new NonRetryableError(
+      `Config domain '${config.domain}' (in ${sourcePath}) does not match deploy domain '${opts.domain}'. Either update the config or pass the matching <domain> argument.`
+    );
+  }
+  const sizeReport = pessimisticSizePreflight(config);
+  if (!sizeReport.ok) {
+    const failing = sizeReport.checks.filter((c) => !c.ok).map((c) => `${c.key}: ${c.bytes}/${c.budget} B`).join(", ");
+    throw new NonRetryableError(
+      `Manifest size preflight failed: ${failing}. Shrink displayName / description / paths or override BULLETIN_TEXT_BUDGET.`
+    );
+  }
+  const configDir = path.dirname(sourcePath);
+  const iconAbs = path.resolve(configDir, config.icon.path);
+  const iconBytes = await readFileOrThrow(iconAbs, "icon");
+  console.log(`
+Manifest publish \u2014 ${config.domain}`);
+  console.log(`  Loaded config: ${sourcePath}`);
+  console.log(`  Uploading icon (${iconBytes.length} B)\u2026`);
+  const iconCid = await storeFile(iconBytes);
+  console.log(`  Icon CID: ${iconCid}`);
+  const executableCids = {};
+  for (const exec of config.executables) {
+    const execAbs = path.resolve(configDir, exec.path);
+    if (opts.buildDirCid && path.resolve(opts.buildDirCid.absPath) === execAbs) {
+      console.log(`  Executable [${exec.kind}] reused build-dir CID: ${opts.buildDirCid.cid}`);
+      executableCids[exec.kind] = opts.buildDirCid.cid;
+      continue;
+    }
+    console.log(`  Uploading executable [${exec.kind}] from ${execAbs}\u2026`);
+    const { storageCid } = await storeDirectory(execAbs, {}, void 0, true);
+    console.log(`  Executable [${exec.kind}] CID: ${storageCid}`);
+    executableCids[exec.kind] = storageCid;
+  }
+  const dotns = await connectDotNS(opts);
+  try {
+    const baseLabel = stripDotSuffix(config.domain);
+    await dotns.ensureContentResolver(baseLabel);
+    const rootManifest = composeRoot(config, iconCid);
+    const rootJson = JSON.stringify(rootManifest);
+    console.log(`  Writing root manifest text record on ${config.domain} (${Buffer.byteLength(rootJson, "utf8")} B)\u2026`);
+    await dotns.setTextRecord(baseLabel, "manifest", rootJson);
+    let textRecordsWritten = 1;
+    for (const exec of config.executables) {
+      const cid = executableCids[exec.kind];
+      if (!cid) throw new NonRetryableError(`Internal: missing CID for executable kind '${exec.kind}'`);
+      const ownership = await dotns.checkSubdomainOwnership(exec.kind, baseLabel);
+      if (!ownership.owned) {
+        if (ownership.owner) {
+          throw new NonRetryableError(
+            `Subname ${exec.kind}.${config.domain} is owned by ${ownership.owner}, not the publisher. Aborting.`
+          );
+        }
+        console.log(`  Registering subname ${exec.kind}.${config.domain}\u2026`);
+        await dotns.registerSubdomain(exec.kind, baseLabel);
+      }
+      await dotns.ensureContentResolver(`${exec.kind}.${baseLabel}`);
+      const subContenthash = `0x${encodeContenthash(cid)}`;
+      console.log(`  Setting contenthash on ${exec.kind}.${config.domain} \u2192 ${cid}\u2026`);
+      await dotns.setContenthash(`${exec.kind}.${baseLabel}`, subContenthash);
+      const execManifest = composeExecutable(exec);
+      const execJson = JSON.stringify(execManifest);
+      console.log(`  Writing executable manifest on ${exec.kind}.${config.domain} (${Buffer.byteLength(execJson, "utf8")} B)\u2026`);
+      await dotns.setTextRecord(`${exec.kind}.${baseLabel}`, "executable", execJson);
+      textRecordsWritten++;
+    }
+    console.log(`  \u2713 ${textRecordsWritten} text record${textRecordsWritten === 1 ? "" : "s"} written.`);
+    return { iconCid, executableCids, textRecordsWritten };
+  } finally {
+    dotns.disconnect();
+  }
+}
+async function readFileOrThrow(p, label) {
+  try {
+    return await fs.readFile(p);
+  } catch (err) {
+    throw new NonRetryableError(`Cannot read ${label} at ${p}: ${err.message}`);
+  }
+}
+async function connectDotNS(opts) {
+  const envId = opts.env ?? "paseo-next-v2";
+  const { doc } = await loadEnvironments();
+  const resolved = resolveEndpoints(doc, envId);
+  const popSelfServe = getPopSelfServeConfig(doc, envId);
+  const deployOptsShim = {
+    mnemonic: opts.mnemonic,
+    derivationPath: opts.derivationPath
+  };
+  const connectOpts = resolveDotnsConnectOptions(
+    deployOptsShim,
+    resolved.assetHub,
+    resolved.autoAccountMapping,
+    resolved.contracts,
+    resolved.nativeToEthRatio,
+    envId,
+    popSelfServe,
+    resolved.registerStorageDeposit
+  );
+  const dotns = new DotNS();
+  await dotns.connect(connectOpts);
+  return dotns;
+}
+function composeRoot(config, iconCid) {
+  return {
+    $v: 1,
+    displayName: config.displayName,
+    description: config.description,
+    icon: { cid: iconCid, format: config.icon.format }
+  };
+}
+function composeExecutable(exec) {
+  if (exec.kind === "app") {
+    return { $v: 1, kind: "app", appVersion: exec.appVersion };
+  }
+  if (exec.kind === "widget") {
+    return {
+      $v: 1,
+      kind: "widget",
+      appVersion: exec.appVersion,
+      dimensions: exec.dimensions,
+      ...exec.description !== void 0 ? { description: exec.description } : {}
+    };
+  }
+  return {
+    $v: 1,
+    kind: "worker",
+    appVersion: exec.appVersion,
+    entrypoint: exec.entrypoint,
+    includes: exec.includes
+  };
+}
+function stripDotSuffix(domain) {
+  return domain.replace(/\.dot$/i, "");
+}
+
+export {
+  publishManifest
+};