@platforma-sdk/block-tools 2.5.91 → 2.6.0

package/dist/cli.mjs

@@ -1,228 +1,257 @@
-var O = Object.defineProperty;
-var j = (i, e, a) => e in i ? O(i, e, { enumerable: !0, configurable: !0, writable: !0, value: a }) : i[e] = a;
-var o = (i, e, a) => j(i, typeof e != "symbol" ? e + "" : e, a);
-import { Command as f, Flags as r } from "@oclif/core";
-import c from "node:path";
-import m from "node:fs";
+var D = Object.defineProperty;
+var q = (l, e, t) => e in l ? D(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
+var i = (l, e, t) => q(l, typeof e != "symbol" ? e + "" : e, t);
+import { Command as m, Flags as s } from "@oclif/core";
+import d from "node:path";
+import f from "node:fs";
 import "zod";
 import "mime-types";
 import "tar";
 import "@milaboratories/resolve-helper";
-import { l as T, B as Y, a as D, s as x, b as I, c as M, d as B, M as _, P as q, g as H } from "./config-VnABe7ki.mjs";
-import { StableChannel as P, overrideDescriptionVersion as J, BlockPackManifest as $, overrideManifestVersion as U } from "@milaboratories/pl-model-middle-layer";
+import { l as Y, B as M, a as B, s as R, b as N, c as J, d as H, M as U, P as K, g as z } from "./config-XBQ2O39y.mjs";
+import { StableChannel as F, overrideDescriptionVersion as W, BlockPackManifest as _, overrideManifestVersion as Z } from "@milaboratories/pl-model-middle-layer";
 import "@milaboratories/pl-model-common";
 import "@milaboratories/ts-helpers";
 import "canonicalize";
 import "lru-cache";
+import { OclifLoggerAdapter as p } from "@milaboratories/ts-helpers-oclif";
 import "undici";
 import "@milaboratories/pl-http";
-import { OclifLoggerAdapter as b } from "@milaboratories/ts-helpers-oclif";
-import L from "yaml";
-const u = class u extends f {
+import $ from "yaml";
+const h = class h extends m {
   async run() {
-    const { flags: e } = await this.parse(u), a = c.resolve(e.modulePath), t = await T(a), s = await Y.parseAsync(
-      D(a).parse(t.meta)
+    const { flags: e } = await this.parse(h), t = d.resolve(e.modulePath), a = await Y(t), r = await M.parseAsync(
+      B(t).parse(a.meta)
     );
-    await m.promises.writeFile(c.resolve(e.destination), JSON.stringify(s));
+    await f.promises.writeFile(d.resolve(e.destination), JSON.stringify(r));
   }
 };
-o(u, "description", "Extracts meta information from blocks package.json and outputs meta.json with embedded binary and textual information linked from the meta section."), o(u, "flags", {
-  modulePath: r.string({
+i(h, "description", "Extracts meta information from blocks package.json and outputs meta.json with embedded binary and textual information linked from the meta section."), i(h, "flags", {
+  modulePath: s.string({
     char: "i",
     summary: "input module path",
     helpValue: "<path>",
     default: "."
   }),
-  destination: r.string({
+  destination: s.string({
     char: "o",
     summary: "output meta.json file",
     helpValue: "<path>",
     required: !0
   })
 });
-let E = u;
-async function K(i) {
+let A = h;
+async function Q(l) {
   try {
-    return await m.promises.readFile(i, "utf8");
+    return await f.promises.readFile(l, "utf8");
   } catch (e) {
     if (e.code === "ENOENT")
       return;
     throw e;
   }
 }
-const p = class p extends f {
+const g = class g extends m {
   async run() {
-    const { flags: e } = await this.parse(p), a = c.resolve(e.modulePath);
-    let { model: t, platforma: s } = require(a);
-    if (t || (t = s), !t) throw new Error('"model" export not found');
-    const { config: l } = t;
-    if (!l)
+    const { flags: e } = await this.parse(g), t = d.resolve(e.modulePath);
+    let { model: a, platforma: r } = require(t);
+    if (a || (a = r), !a) throw new Error('"model" export not found');
+    const { config: o } = a;
+    if (!o)
       throw new Error(
         'Malformed "model" object, check it is created with "BlockModel" and ".done()" is executed as the call in the chain.'
       );
-    if (!("canRun" in l || "inputsValid" in l) || !("outputs" in l) || !("sections" in l))
+    if (!("canRun" in o || "inputsValid" in o) || !("outputs" in o) || !("sections" in o))
       throw new Error('"config" has unexpected structure');
-    const d = await K(e.sourceBundle);
-    d !== void 0 && (l.code = {
+    const c = await Q(e.sourceBundle);
+    c !== void 0 && (o.code = {
       type: "plain",
-      content: d
-    }), await m.promises.writeFile(c.resolve(e.destination), JSON.stringify(l));
+      content: c
+    }), await f.promises.writeFile(d.resolve(e.destination), JSON.stringify(o));
   }
 };
-o(p, "description", "Extracts and outputs block model JSON from pre-built block model module"), o(p, "flags", {
-  modulePath: r.string({
+i(g, "description", "Extracts and outputs block model JSON from pre-built block model module"), i(g, "flags", {
+  modulePath: s.string({
     char: "i",
     summary: "input module path",
     helpValue: "<path>",
     default: "."
   }),
-  sourceBundle: r.string({
+  sourceBundle: s.string({
     char: "b",
     summary: "bundled model code to embed into the model for callback-based rendering to work",
     helpValue: "<path>",
     default: "./dist/bundle.js"
   }),
-  destination: r.string({
+  destination: s.string({
     char: "o",
     summary: "output model file",
     helpValue: "<path>",
     default: "./dist/model.json"
   })
 });
-let R = p;
-const h = class h extends f {
+let V = g;
+const y = class y extends m {
   async run() {
-    const { flags: e } = await this.parse(h);
-    let a = await T(c.resolve(e.modulePath));
-    e["version-override"] && (a = J(a, e["version-override"]));
-    const t = x(e.registry), s = new I(t, new b(this));
-    e.unmark ? await s.removePackageFromChannel(a.id, e.channel) : await s.addPackageToChannel(a.id, e.channel), e.refresh && await s.updateIfNeeded();
+    const { flags: e } = await this.parse(y), t = R(e.registry), r = await new N(t, new p(this)).listGlobalOverviewSnapshots();
+    if (e.json)
+      this.log(JSON.stringify(r, null, 2));
+    else if (r.length === 0)
+      this.log("No snapshots found.");
+    else {
+      this.log(`Found ${r.length} snapshot(s):
+`);
+      for (const o of r)
+        this.log(`  ${o.timestamp}`), this.log(`    Path: ${o.path}`), this.log("");
+    }
   }
 };
-o(h, "description", "Mark target block stable"), o(h, "flags", {
-  modulePath: r.string({
+i(y, "description", "List all available global overview snapshots in the registry"), i(y, "flags", {
+  registry: s.string({
+    char: "r",
+    summary: "full address of the registry",
+    helpValue: "<address>",
+    env: "PL_REGISTRY",
+    required: !0
+  }),
+  json: s.boolean({
+    summary: "output in JSON format",
+    default: !1
+  })
+});
+let I = y;
+const w = class w extends m {
+  async run() {
+    const { flags: e } = await this.parse(w);
+    let t = await Y(d.resolve(e.modulePath));
+    e["version-override"] && (t = W(t, e["version-override"]));
+    const a = R(e.registry), r = new N(a, new p(this));
+    e.unmark ? await r.removePackageFromChannel(t.id, e.channel) : await r.addPackageToChannel(t.id, e.channel), e.refresh && await r.updateIfNeeded();
+  }
+};
+i(w, "description", "Mark target block stable"), i(w, "flags", {
+  modulePath: s.string({
     char: "i",
     summary: "input module path",
     helpValue: "<path>",
     default: "."
   }),
-  channel: r.string({
+  channel: s.string({
     char: "c",
     hidden: !0,
     summary: "custom channel",
     helpValue: "<channel name>",
-    default: P
+    default: F
   }),
-  "version-override": r.file({
+  "version-override": s.file({
     char: "v",
     summary: "override package version"
   }),
-  registry: r.string({
+  registry: s.string({
     char: "r",
     summary: "full address of the registry",
     helpValue: "<address>",
     env: "PL_REGISTRY",
     required: !0
   }),
-  refresh: r.boolean({
+  refresh: s.boolean({
     summary: "refresh repository after adding the package",
     default: !0,
     allowNo: !0,
     env: "PL_REGISTRY_REFRESH"
   }),
-  unmark: r.boolean({
+  unmark: s.boolean({
     summary: 'reverses meaning of this command, flag can be used to remove "stable" flag from the package',
     default: !1
   })
 });
-let N = h;
-const g = class g extends f {
+let x = w;
+const v = class v extends m {
   async run() {
-    const { flags: e } = await this.parse(g), a = await M(c.resolve(e.modulePath));
-    await B(a, c.resolve(e.destinationPath));
+    const { flags: e } = await this.parse(v), t = await J(d.resolve(e.modulePath));
+    await H(t, d.resolve(e.destinationPath));
   }
 };
-o(g, "description", "Builds block pack and outputs a block pack manifest consolidating all references assets into a single folder"), o(g, "flags", {
-  modulePath: r.string({
+i(v, "description", "Builds block pack and outputs a block pack manifest consolidating all references assets into a single folder"), i(v, "flags", {
+  modulePath: s.string({
     char: "i",
     summary: "input module path",
     helpValue: "<path>",
     default: "."
   }),
-  destinationPath: r.string({
+  destinationPath: s.string({
     char: "o",
     summary: "output folder",
     helpValue: "<path>",
     default: "./block-pack"
   })
 });
-let F = g;
-function C(i, e) {
-  const a = { ...i };
-  for (const t in e)
-    e[t] && typeof e[t] == "object" && !Array.isArray(e[t]) && a[t] && typeof a[t] == "object" && !Array.isArray(a[t]) ? a[t] = C(a[t], e[t]) : a[t] = e[t];
-  return a;
+let L = v;
+function O(l, e) {
+  const t = { ...l };
+  for (const a in e)
+    e[a] && typeof e[a] == "object" && !Array.isArray(e[a]) && t[a] && typeof t[a] == "object" && !Array.isArray(t[a]) ? t[a] = O(t[a], e[a]) : t[a] = e[a];
+  return t;
 }
-const y = class y extends f {
+const b = class b extends m {
   async run() {
-    const { flags: e } = await this.parse(y), a = c.resolve(e.manifest), t = JSON.parse(await m.promises.readFile(a, { encoding: "utf-8" }));
-    let s = $.parse(t);
-    s = C(t, s);
-    const l = c.dirname(a);
-    this.log(`Manifest root = ${l}`), e["version-override"] && (s = U(s, e["version-override"]));
-    const d = x(e.registry), n = new I(d, new b(this));
+    const { flags: e } = await this.parse(b), t = d.resolve(e.manifest), a = JSON.parse(await f.promises.readFile(t, { encoding: "utf-8" }));
+    let r = _.parse(a);
+    r = O(a, r);
+    const o = d.dirname(t);
+    this.log(`Manifest root = ${o}`), e["version-override"] && (r = Z(r, e["version-override"]));
+    const c = R(e.registry), n = new N(c, new p(this));
     await n.publishPackage(
-      s,
-      async (k) => Buffer.from(await m.promises.readFile(c.resolve(l, k)))
-    ), e.unstable || (this.log(`Adding package to ${P} channel...`), await n.addPackageToChannel(s.description.id, P)), e.refresh && await n.updateIfNeeded();
+      r,
+      async (u) => Buffer.from(await f.promises.readFile(d.resolve(o, u)))
+    ), e.unstable || (this.log(`Adding package to ${F} channel...`), await n.addPackageToChannel(r.description.id, F)), e.refresh && await n.updateIfNeeded();
   }
 };
-o(y, "description", "Publishes the block package and refreshes the registry (for v2 block-pack schema)"), o(y, "flags", {
-  registry: r.string({
+i(b, "description", "Publishes the block package and refreshes the registry (for v2 block-pack schema)"), i(b, "flags", {
+  registry: s.string({
     char: "r",
     summary: "full address of the registry",
     helpValue: "<address>",
     env: "PL_REGISTRY",
     required: !0
   }),
-  manifest: r.file({
+  manifest: s.file({
     char: "m",
     summary: "manifest file path",
     exists: !0,
-    default: `./block-pack/${_}`
+    default: `./block-pack/${U}`
   }),
-  "version-override": r.file({
+  "version-override": s.file({
     char: "v",
     summary: "override package version"
   }),
-  refresh: r.boolean({
+  refresh: s.boolean({
     summary: "refresh repository after adding the package",
     default: !0,
     allowNo: !0,
     env: "PL_REGISTRY_REFRESH"
   }),
-  unstable: r.boolean({
+  unstable: s.boolean({
     summary: "do not add the published package to stable channel",
     default: !1,
     env: "PL_PUBLISH_UNSTABLE"
   })
 });
-let A = y;
-const w = class w extends f {
+let G = b;
+const k = class k extends m {
   async run() {
-    const { flags: e } = await this.parse(w), a = x(e.registry);
-    await new I(a, new b(this)).updateIfNeeded(e.mode);
+    const { flags: e } = await this.parse(k), t = R(e.registry);
+    await new N(t, new p(this)).updateIfNeeded(e.mode);
   }
 };
-o(w, "description", "Refresh overview files based on published but not proecessed artefacts"), o(w, "flags", {
-  registry: r.string({
+i(k, "description", "Refresh overview files based on published but not proecessed artefacts"), i(k, "flags", {
+  registry: s.string({
     char: "r",
     summary: "full address of the registry",
     helpValue: "<address>",
     env: "PL_REGISTRY",
     required: !0
   }),
-  mode: r.string({
+  mode: s.string({
     char: "m",
     summary: 'refresh mode (allowed valiues: "force", "normal", "dry-run")',
     helpValue: "<mode>",
@@ -231,92 +260,142 @@ o(w, "description", "Refresh overview files based on published but not proecesse
     default: "normal"
   })
 });
-let S = w;
-function z(i) {
-  const e = i.match(/(?<destName>[^\/\\]+)=(?<src>.*)/);
+let T = k;
+const P = class P extends m {
+  async run() {
+    const { flags: e } = await this.parse(P), t = R(e.registry), a = new N(t, new p(this)), r = await a.listGlobalOverviewSnapshots();
+    if (r.find((c) => c.timestamp === e.snapshot) || this.error(`Snapshot '${e.snapshot}' not found. Available snapshots:
+${r.map((c) => `  - ${c.timestamp}`).join(`
+`) || "  (none)"}`), !e["skip-confirmation"]) {
+      const n = (await import("node:readline")).createInterface({
+        input: process.stdin,
+        output: process.stdout
+      }), u = await new Promise((S) => {
+        n.question(
+          `⚠️  This will overwrite the current global overview with snapshot '${e.snapshot}'.
+Are you sure you want to continue? (y/N): `,
+          S
+        );
+      });
+      if (n.close(), u.toLowerCase() !== "y" && u.toLowerCase() !== "yes") {
+        this.log("Restore cancelled.");
+        return;
+      }
+    }
+    try {
+      await a.restoreGlobalOverviewFromSnapshot(e.snapshot), this.log(`✅ Successfully restored global overview from snapshot '${e.snapshot}'`);
+    } catch (c) {
+      this.error(`Failed to restore from snapshot: ${c}`);
+    }
+  }
+};
+i(P, "description", "Restore global overview from a snapshot"), i(P, "flags", {
+  registry: s.string({
+    char: "r",
+    summary: "full address of the registry",
+    helpValue: "<address>",
+    env: "PL_REGISTRY",
+    required: !0
+  }),
+  snapshot: s.string({
+    char: "s",
+    summary: "snapshot timestamp ID to restore from",
+    helpValue: "<timestamp>",
+    required: !0
+  }),
+  "skip-confirmation": s.boolean({
+    summary: "skip confirmation prompt (use with caution)",
+    default: !1
+  })
+});
+let C = P;
+function X(l) {
+  const e = l.match(/(?<destName>[^\/\\]+)=(?<src>.*)/);
   if (e) {
-    const { src: a, destName: t } = e.groups;
-    return { src: a, destName: t };
+    const { src: t, destName: a } = e.groups;
+    return { src: t, destName: a };
   } else
-    return { src: i, destName: c.basename(i) };
+    return { src: l, destName: d.basename(l) };
 }
-const W = r.custom({
+const ee = s.custom({
   summary: "target files to upload",
   helpValue: "file_path | package_name=file_path",
-  parse: async (i) => z(i)
-}), Z = ["registry", "organization", "package", "version"], v = class v extends f {
+  parse: async (l) => X(l)
+}), te = ["registry", "organization", "package", "version"], E = class E extends m {
   async run() {
-    const { flags: e } = await this.parse(v), a = q.parse({});
-    for (const n of Z) e[n] && (a[n] = e[n]);
-    e.meta && (e.meta.endsWith(".json") ? a.meta = JSON.parse(
-      await m.promises.readFile(e.meta, { encoding: "utf-8" })
-    ) : e.meta.endsWith(".yaml") && (a.meta = L.parse(
-      await m.promises.readFile(e.meta, { encoding: "utf-8" })
+    const { flags: e } = await this.parse(E), t = K.parse({});
+    for (const n of te) e[n] && (t[n] = e[n]);
+    e.meta && (e.meta.endsWith(".json") ? t.meta = JSON.parse(
+      await f.promises.readFile(e.meta, { encoding: "utf-8" })
+    ) : e.meta.endsWith(".yaml") && (t.meta = $.parse(
+      await f.promises.readFile(e.meta, { encoding: "utf-8" })
     )));
     for (const n of e.file)
-      a.files[n.destName] = n.src;
-    const t = await H(a);
-    this.log(L.stringify(t.conf));
-    const s = t.createRegistry(new b(this)), l = t.fullPackageName, d = s.constructNewPackage(l);
-    for (const [n, k] of Object.entries(t.conf.files)) {
-      this.log(`Uploading ${k} -> ${n} ...`);
-      const G = await m.promises.readFile(k);
-      await d.addFile(n, G);
+      t.files[n.destName] = n.src;
+    const a = await z(t);
+    this.log($.stringify(a.conf));
+    const r = a.createRegistry(new p(this)), o = a.fullPackageName, c = r.constructNewPackage(o);
+    for (const [n, u] of Object.entries(a.conf.files)) {
+      this.log(`Uploading ${u} -> ${n} ...`);
+      const S = await f.promises.readFile(u);
+      await c.addFile(n, S);
     }
-    this.log("Uploading meta information..."), await d.writeMeta(t.conf.meta), await d.finish(), e.refresh && await s.updateIfNeeded();
+    this.log("Uploading meta information..."), await c.writeMeta(a.conf.meta), await c.finish(), e.refresh && await r.updateIfNeeded();
   }
 };
-o(v, "description", "Uploads V1 package and refreshes the registry"), o(v, "flags", {
-  registry: r.string({
+i(E, "description", "Uploads V1 package and refreshes the registry"), i(E, "flags", {
+  registry: s.string({
     char: "r",
     summary: "full address of the registry or alias from .pl.reg",
     helpValue: "<address|alias>",
     env: "PL_REGISTRY"
   }),
-  organization: r.string({
+  organization: s.string({
     char: "o",
     summary: "target organisation",
     env: "PL_PACKAGE_ORGANIZATION"
   }),
-  package: r.string({
+  package: s.string({
     char: "p",
     summary: "target package",
     env: "PL_PACKAGE_NAME"
   }),
-  version: r.string({
+  version: s.string({
     char: "v",
     summary: "target version",
     env: "PL_PACKAGE_VERSION"
   }),
-  meta: r.file({
+  meta: s.file({
     char: "m",
     summary: "json file containing meta information to associate with tha package",
     exists: !0
   }),
-  file: W({
+  file: ee({
     char: "f",
     summary: "package files",
     multiple: !0,
     default: []
   }),
-  refresh: r.boolean({
+  refresh: s.boolean({
     summary: "refresh repository after adding the package",
     default: !0,
     allowNo: !0,
     env: "PL_REGISTRY_REFRESH"
   })
 });
-let V = v;
-const ge = {
-  "build-meta": E,
-  "build-model": R,
-  "mark-stable": N,
-  pack: F,
-  publish: A,
-  "refresh-registry": S,
-  "upload-package-v1": V
+let j = E;
+const be = {
+  "build-meta": A,
+  "build-model": V,
+  "list-overview-snapshots": I,
+  "mark-stable": x,
+  pack: L,
+  publish: G,
+  "refresh-registry": T,
+  "restore-overview-from-snapshot": C,
+  "upload-package-v1": j
 };
 export {
-  ge as COMMANDS
+  be as COMMANDS
 };
 //# sourceMappingURL=cli.mjs.map