@xano/sdk 1.0.0

package/dist/loop-ALIZLOSX.js

@@ -0,0 +1,191 @@
+import {
+  ROUND_TRIP_KINDS,
+  identityMatcher,
+  kindIsRunnable
+} from "./chunk-NWKXM5RD.js";
+import {
+  rowLabeler,
+  sectionKind
+} from "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-YU4HSQW7.js";
+import {
+  normalize
+} from "./chunk-L5JYN3NM.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/validate/guid-remap.ts
+function guidOf(obj) {
+  const v = obj["guid"];
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asRecords(v) {
+  return Array.isArray(v) ? v.filter((o) => o !== null && typeof o === "object") : [];
+}
+function payloadGuidRemap(compiledPayload, exportedPayload) {
+  const remap = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(compiledPayload)) {
+    const fetched = asRecords(exportedPayload[key]);
+    if (fetched.length === 0) continue;
+    const match = identityMatcher(key, fetched, exportedPayload, compiledPayload);
+    for (const obj of asRecords(compiledPayload[key])) {
+      const mine = guidOf(obj);
+      if (mine === void 0) continue;
+      const resolved = match(obj);
+      if (resolved.outcome !== "found") continue;
+      const theirs = guidOf(resolved.fetched);
+      if (theirs === void 0 || theirs === mine) continue;
+      remap.set(mine, theirs);
+    }
+  }
+  return remap;
+}
+var EMBEDDED = [
+  { prefix: "dbo=", suffix: "" },
+  { prefix: "", suffix: "_mvpschema" }
+];
+function remapGuids(value, remap) {
+  if (remap.size === 0) return value;
+  return walk(value, remap);
+}
+function walk(value, remap) {
+  if (typeof value === "string") return remapString(value, remap);
+  if (Array.isArray(value)) return value.map((v) => walk(v, remap));
+  if (value !== null && typeof value === "object") {
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const [k, v] of Object.entries(value)) out[k] = walk(v, remap);
+    return out;
+  }
+  return value;
+}
+function remapString(value, remap) {
+  const bare = remap.get(value);
+  if (bare !== void 0) return bare;
+  for (const { prefix, suffix } of EMBEDDED) {
+    if (!value.startsWith(prefix) || !value.endsWith(suffix)) continue;
+    if (value.length <= prefix.length + suffix.length) continue;
+    const mapped = remap.get(value.slice(prefix.length, value.length - suffix.length));
+    if (mapped !== void 0) return `${prefix}${mapped}${suffix}`;
+  }
+  return value;
+}
+
+// src/validate/loop.ts
+async function runValidateLoop(client, bundleText, options = {}) {
+  const bundle = JSON.parse(bundleText);
+  const payload = bundle.payload ?? {};
+  let imported;
+  try {
+    imported = await client.importBundle(bundleText);
+  } catch (err) {
+    return {
+      accepted: false,
+      importError: err instanceof Error ? err.message : String(err),
+      workspaceId: void 0,
+      roundTrip: [],
+      unchecked: []
+    };
+  }
+  const workspaceId = imported.workspaceId;
+  const multidoc = options.includeEngineRendering === true && workspaceId !== void 0 && client.exportMultidoc !== void 0 ? client.exportMultidoc(workspaceId).then(
+    (text) => ({ text }),
+    (err) => ({ error: err instanceof Error ? err.message : String(err) })
+  ) : void 0;
+  const present = ROUND_TRIP_KINDS.map((k) => ({ kind: k.key, compiled: asRecords2(payload[k.key]) })).filter(
+    (p) => p.compiled.length > 0
+  );
+  if (workspaceId === void 0 || present.length === 0 && options.includeEngineRendering !== true) {
+    return {
+      accepted: true,
+      workspaceId,
+      roundTrip: [],
+      unchecked: present.map((p) => ({ kind: p.kind, count: p.compiled.length }))
+    };
+  }
+  const exported = await client.exportWorkspace(workspaceId);
+  const roundTrip = [];
+  const unchecked = [];
+  const remap = payloadGuidRemap(payload, exported.payload);
+  const remapped = remapGuids(payload, remap);
+  const labelOf = rowLabeler(payload);
+  for (const { kind, compiled } of present) {
+    const fetched = asRecords2(exported.payload[kind]);
+    if (fetched.length === 0) {
+      unchecked.push({ kind, count: compiled.length });
+      continue;
+    }
+    const match = identityMatcher(kind, fetched, exported.payload, payload);
+    const remappedKind = asRecords2(remapped[kind]);
+    for (const [i, obj] of compiled.entries()) {
+      const name = typeof obj.name === "string" ? obj.name : "(unnamed)";
+      const named = { kind, sdkKind: sectionKind(kind, obj), name, label: labelOf(kind, obj) };
+      const resolved = match(obj);
+      if (resolved.outcome !== "found") {
+        roundTrip.push({ ...named, status: resolved.outcome, diffs: [], fetched: void 0 });
+      } else {
+        const diffs = deepDiff(normalize(remappedKind[i] ?? obj), normalize(resolved.fetched));
+        roundTrip.push({ ...named, status: diffs.length === 0 ? "match" : "diff", diffs, fetched: resolved.fetched });
+      }
+    }
+  }
+  const result = { accepted: true, workspaceId, roundTrip, unchecked };
+  if (options.includeEngineRendering === true) {
+    const fetched = multidoc === void 0 ? { error: "(no workspace to read back)" } : await multidoc;
+    result.engineComparison = {
+      engineRendering: "error" in fetched ? { kind: "error", why: fetched.error } : { kind: "text", text: fetched.text },
+      exportedPayload: exported.payload,
+      remappedPayload: remapped
+    };
+  }
+  return result;
+}
+function runnableFunctionNames(entries) {
+  return entries.filter((e) => kindIsRunnable(e.kind) && (e.status === "match" || e.status === "diff")).map((e) => e.name);
+}
+function asRecords2(v) {
+  return Array.isArray(v) ? v.filter((o) => o !== null && typeof o === "object") : [];
+}
+function deepDiff(expected, actual, path = "$") {
+  if (expected === actual) return [];
+  const bothObjects = expected !== null && actual !== null && typeof expected === "object" && typeof actual === "object";
+  if (!bothObjects) return [{ path, expected, actual }];
+  const expIsArr = Array.isArray(expected);
+  const actIsArr = Array.isArray(actual);
+  if (expIsArr !== actIsArr) return [{ path, expected, actual }];
+  if (expIsArr && actIsArr) {
+    const len = Math.max(expected.length, actual.length);
+    const out2 = [];
+    for (let i = 0; i < len; i++) out2.push(...deepDiff(expected[i], actual[i], `${path}[${i}]`));
+    return out2;
+  }
+  const e = expected;
+  const a = actual;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(a)]);
+  const out = [];
+  for (const k of keys) out.push(...deepDiff(e[k], a[k], `${path}.${k}`));
+  return out;
+}
+export {
+  deepDiff,
+  runValidateLoop,
+  runnableFunctionNames
+};
+//# sourceMappingURL=loop-ALIZLOSX.js.map