@xano/sdk 1.0.0

package/dist/chunk-NZOWWHU5.js

@@ -0,0 +1,196 @@
+import {
+  getLockedGuid
+} from "./chunk-4BW2SG2N.js";
+import {
+  describeEntry
+} from "./chunk-CIMQZRRE.js";
+import {
+  md5Hex
+} from "./chunk-OHX6MIUZ.js";
+
+// src/refs/guid.ts
+var REFERENCEABLE_KIND_PAYLOAD_KEYS = {
+  function: "function",
+  query: "query",
+  tool: "tool",
+  // The two other primitives an MCP server exposes. An `mcpServer()`'s
+  // `prompts`/`resources` entries resolve them by this guid, exactly as its
+  // `tools` entries resolve a tool.
+  prompt: "prompt",
+  resource: "resource",
+  // MCP servers and agents are distinct kinds that both persist as
+  // obj_type=toolset — they share the "toolset" migrate type, so both derive
+  // md5("toolset:"+name) and a same-name pair correctly collides. A trigger
+  // binds either by resolving against this same "toolset" migrate type.
+  mcp_server: "toolset",
+  agent: "toolset",
+  task: "task",
+  trigger: "trigger",
+  middleware: "middleware",
+  addon: "addon",
+  table: "dbo",
+  api_group: "app",
+  // Realtime: `realtime_server` -> `channel` -> `message`. Kind names match the
+  // engine's object types (the authoring factories carry the `realtime` prefix
+  // instead). Channel and message names are NOT workspace-unique, so their
+  // seeds are composed — see {@link realtimeChannelSeedName}.
+  realtime_server: "realtime_server",
+  channel: "channel",
+  message: "message",
+  // A container workload. Nothing in a stack resolves it by guid — `s.microservice.request`
+  // addresses one by NAME — but it is listed here because it is a top-level
+  // guid-tracked object, and the codegen index only places objects it recognises.
+  microservice: "microservice",
+  // An end-to-end test: a named stack of runs plus `expect` assertions. Kind
+  // name and migrate type are the same string, so the mapping is identity.
+  // Membership here is load-bearing twice over: `s.workflow_test.call` already
+  // resolves its target through this map, and `Xano#encodeOne` stamps a guid
+  // only for kinds in `REFERENCEABLE_KINDS` — and the engine REFUSES to export a
+  // workflow test that has none ("Missing workflow test guid."), a failure that
+  // surfaces only against a live instance.
+  workflow_test: "workflow_test",
+  // Knowledge is listed here for IDENTITY, not for referencing — nothing in a
+  // stack resolves a knowledge item. Membership is what stamps its guid in
+  // `Xano#encodeOne` and what makes `knowledge:<name>` a valid lock key, and
+  // BOTH are load-bearing: the engine re-mints guids on every replace import
+  // while a merge import upserts BY guid, so without a locked identity the
+  // second promote inserts `<name>_01` beside the item it should have
+  // updated. Measured, not theorised.
+  knowledge: "knowledge"
+};
+var REFERENCEABLE_KINDS = new Set(Object.keys(REFERENCEABLE_KIND_PAYLOAD_KEYS));
+var SEED_SEP = "|";
+function seedPart(kind, label, value) {
+  if (!value) {
+    throw new Error(`realtime ${kind} identity: \`${label}\` is required to derive a stable guid.`);
+  }
+  if (value.includes(SEED_SEP)) {
+    throw new Error(
+      `realtime ${kind} identity: \`${label}\` must not contain "${SEED_SEP}" (got "${value}") \u2014 it separates the components of the guid seed, so a name carrying it could collide with a different object.`
+    );
+  }
+  return value;
+}
+function realtimeChannelSeedName(server, path) {
+  return [seedPart("channel", "server", server), seedPart("channel", "path", path)].join(SEED_SEP);
+}
+function realtimeMessageSeedName(server, channelPath, name) {
+  return [
+    seedPart("message", "server", server),
+    seedPart("message", "channel", channelPath),
+    seedPart("message", "name", name)
+  ].join(SEED_SEP);
+}
+function querySeedName(group, verb, name) {
+  return [
+    group === "" ? "" : seedPart("query", "apiGroup", group),
+    seedPart("query", "verb", verb),
+    seedPart("query", "name", name)
+  ].join(SEED_SEP);
+}
+function deriveQueryGuid(group, verb, name) {
+  const seed = `query:${querySeedName(group, verb, name)}`;
+  const guid = getLockedGuid(seed) ?? getLockedGuid(`query:${name}`) ?? rawDeriveGuid(seed);
+  SEEN_SEEDS.set(guid, seed);
+  return guid;
+}
+function queryGroupComponent(ref) {
+  if (ref.apiGroupId !== void 0) return `#${ref.apiGroupId}`;
+  const group = ref.apiGroup;
+  if (group === void 0) return "";
+  return typeof group === "string" ? group : group.name;
+}
+function resolveQueryRef(target, where) {
+  const t = target;
+  const named = typeof t === "string" || typeof t === "object" && t !== null && !Array.isArray(t) && (typeof t.name === "string" || typeof t.guid === "string");
+  if (!named) {
+    throw new Error(
+      `${where ?? "Cannot resolve query reference"}${where ? " must be" : ": pass"} the query() def handle, or a { name, guid } pair for an object addressed by explicit identity \u2014 got ${describeEntry(t)}.`
+    );
+  }
+  if (typeof target !== "string" && target.guid) {
+    if (target.name) SEEN_SEEDS.set(target.guid, `query:${target.name}`);
+    return target.guid;
+  }
+  const handle = typeof target === "string" ? void 0 : target;
+  if (handle?.verb !== void 0 && handle.name) {
+    return deriveQueryGuid(queryGroupComponent(handle), handle.verb, handle.name);
+  }
+  const label = typeof target === "string" ? `"${target}"` : `"${handle?.name ?? "?"}"`;
+  throw new Error(
+    `${where ? `${where}: cannot resolve` : "Cannot resolve"} query reference ${label}: a query's identity is composed from its api group, verb, and name, so a bare name cannot identify one. Pass the query() def handle (it carries all three), or a { name, guid } pair to address an object by explicit identity.`
+  );
+}
+function rawDeriveGuid(seed) {
+  return md5Hex(seed);
+}
+function deriveGuid(type, name) {
+  const seed = `${type}:${name}`;
+  const guid = getLockedGuid(seed) ?? rawDeriveGuid(seed);
+  SEEN_SEEDS.set(guid, seed);
+  return guid;
+}
+var SEEN_SEEDS = /* @__PURE__ */ new Map();
+function guidSeedHint(guid) {
+  return SEEN_SEEDS.get(guid);
+}
+var BARE_NAME_GUIDS = /* @__PURE__ */ new Set();
+var HANDLE_GUIDS = /* @__PURE__ */ new Set();
+function refSpelling(guid) {
+  if (BARE_NAME_GUIDS.has(guid)) return "name";
+  if (HANDLE_GUIDS.has(guid)) return "handle";
+  return void 0;
+}
+function noteHandleRef(guid) {
+  HANDLE_GUIDS.add(guid);
+}
+var REF_KIND = {
+  dbo: "table",
+  query: "API endpoint",
+  function: "function",
+  addon: "addon",
+  task: "task",
+  tool: "tool",
+  prompt: "prompt",
+  resource: "resource",
+  trigger: "trigger",
+  middleware: "middleware",
+  workflow_test: "workflowTest"
+};
+function resolveRef(type, target, where, kindLabel) {
+  const t = target;
+  if (typeof t === "object" && t !== null && typeof t.guid === "string" && t.guid) {
+    const handle = t;
+    if (handle.name) SEEN_SEEDS.set(handle.guid, `${type}:${handle.name}`);
+    HANDLE_GUIDS.add(handle.guid);
+    return handle.guid;
+  }
+  const name = typeof t === "string" ? t : typeof t === "object" && t !== null ? t.name : void 0;
+  if (typeof name === "string" && name !== "") {
+    const guid = deriveGuid(type, name);
+    (typeof t === "string" ? BARE_NAME_GUIDS : HANDLE_GUIDS).add(guid);
+    return guid;
+  }
+  const kind = kindLabel ?? REF_KIND[type] ?? type;
+  const got = t === null ? "null" : Array.isArray(t) ? `an array (${t.length} item${t.length === 1 ? "" : "s"})` : typeof t === "object" ? "an object with neither a name nor a guid" : typeof t === "string" ? "an empty name" : `${typeof t} ${String(t)}`;
+  throw new Error(
+    `${where === void 0 ? "Cannot resolve a" : `${where}: cannot resolve the`} ${kind} reference \u2014 pass the ${kind}'s def handle or its name; got ${got}.`
+  );
+}
+
+export {
+  REFERENCEABLE_KIND_PAYLOAD_KEYS,
+  REFERENCEABLE_KINDS,
+  realtimeChannelSeedName,
+  realtimeMessageSeedName,
+  deriveQueryGuid,
+  queryGroupComponent,
+  resolveQueryRef,
+  rawDeriveGuid,
+  deriveGuid,
+  guidSeedHint,
+  refSpelling,
+  noteHandleRef,
+  resolveRef
+};
+//# sourceMappingURL=chunk-NZOWWHU5.js.map

package/dist/chunk-OHX6MIUZ.js

@@ -0,0 +1,184 @@
+// src/util/hash.ts
+var utf8 = new TextEncoder();
+function toBytes(input) {
+  return typeof input === "string" ? utf8.encode(input) : input;
+}
+function md5Bytes(input) {
+  const msg = toBytes(input);
+  const len = msg.length;
+  const withPad = (len + 8 >>> 6) + 1;
+  const words = new Int32Array(withPad * 16);
+  for (let i = 0; i < len; i++) {
+    const idx = i >> 2;
+    words[idx] = words[idx] | msg[i] << i % 4 * 8;
+  }
+  const padIdx = len >> 2;
+  words[padIdx] = words[padIdx] | 128 << len % 4 * 8;
+  words[words.length - 2] = len * 8;
+  let a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+  const add = (x, y) => x + y | 0;
+  const rol = (n, s) => n << s | n >>> 32 - s;
+  const cmn = (q, a0, b0, x, s, t) => add(rol(add(add(a0, q), add(x, t)), s), b0);
+  const ff = (a0, b0, c0, d0, x, s, t) => cmn(b0 & c0 | ~b0 & d0, a0, b0, x, s, t);
+  const gg = (a0, b0, c0, d0, x, s, t) => cmn(b0 & d0 | c0 & ~d0, a0, b0, x, s, t);
+  const hh = (a0, b0, c0, d0, x, s, t) => cmn(b0 ^ c0 ^ d0, a0, b0, x, s, t);
+  const ii = (a0, b0, c0, d0, x, s, t) => cmn(c0 ^ (b0 | ~d0), a0, b0, x, s, t);
+  for (let i = 0; i < words.length; i += 16) {
+    const oa = a, ob = b, oc = c, od = d;
+    const w = (j) => words[i + j];
+    a = ff(a, b, c, d, w(0), 7, -680876936);
+    d = ff(d, a, b, c, w(1), 12, -389564586);
+    c = ff(c, d, a, b, w(2), 17, 606105819);
+    b = ff(b, c, d, a, w(3), 22, -1044525330);
+    a = ff(a, b, c, d, w(4), 7, -176418897);
+    d = ff(d, a, b, c, w(5), 12, 1200080426);
+    c = ff(c, d, a, b, w(6), 17, -1473231341);
+    b = ff(b, c, d, a, w(7), 22, -45705983);
+    a = ff(a, b, c, d, w(8), 7, 1770035416);
+    d = ff(d, a, b, c, w(9), 12, -1958414417);
+    c = ff(c, d, a, b, w(10), 17, -42063);
+    b = ff(b, c, d, a, w(11), 22, -1990404162);
+    a = ff(a, b, c, d, w(12), 7, 1804603682);
+    d = ff(d, a, b, c, w(13), 12, -40341101);
+    c = ff(c, d, a, b, w(14), 17, -1502002290);
+    b = ff(b, c, d, a, w(15), 22, 1236535329);
+    a = gg(a, b, c, d, w(1), 5, -165796510);
+    d = gg(d, a, b, c, w(6), 9, -1069501632);
+    c = gg(c, d, a, b, w(11), 14, 643717713);
+    b = gg(b, c, d, a, w(0), 20, -373897302);
+    a = gg(a, b, c, d, w(5), 5, -701558691);
+    d = gg(d, a, b, c, w(10), 9, 38016083);
+    c = gg(c, d, a, b, w(15), 14, -660478335);
+    b = gg(b, c, d, a, w(4), 20, -405537848);
+    a = gg(a, b, c, d, w(9), 5, 568446438);
+    d = gg(d, a, b, c, w(14), 9, -1019803690);
+    c = gg(c, d, a, b, w(3), 14, -187363961);
+    b = gg(b, c, d, a, w(8), 20, 1163531501);
+    a = gg(a, b, c, d, w(13), 5, -1444681467);
+    d = gg(d, a, b, c, w(2), 9, -51403784);
+    c = gg(c, d, a, b, w(7), 14, 1735328473);
+    b = gg(b, c, d, a, w(12), 20, -1926607734);
+    a = hh(a, b, c, d, w(5), 4, -378558);
+    d = hh(d, a, b, c, w(8), 11, -2022574463);
+    c = hh(c, d, a, b, w(11), 16, 1839030562);
+    b = hh(b, c, d, a, w(14), 23, -35309556);
+    a = hh(a, b, c, d, w(1), 4, -1530992060);
+    d = hh(d, a, b, c, w(4), 11, 1272893353);
+    c = hh(c, d, a, b, w(7), 16, -155497632);
+    b = hh(b, c, d, a, w(10), 23, -1094730640);
+    a = hh(a, b, c, d, w(13), 4, 681279174);
+    d = hh(d, a, b, c, w(0), 11, -358537222);
+    c = hh(c, d, a, b, w(3), 16, -722521979);
+    b = hh(b, c, d, a, w(6), 23, 76029189);
+    a = hh(a, b, c, d, w(9), 4, -640364487);
+    d = hh(d, a, b, c, w(12), 11, -421815835);
+    c = hh(c, d, a, b, w(15), 16, 530742520);
+    b = hh(b, c, d, a, w(2), 23, -995338651);
+    a = ii(a, b, c, d, w(0), 6, -198630844);
+    d = ii(d, a, b, c, w(7), 10, 1126891415);
+    c = ii(c, d, a, b, w(14), 15, -1416354905);
+    b = ii(b, c, d, a, w(5), 21, -57434055);
+    a = ii(a, b, c, d, w(12), 6, 1700485571);
+    d = ii(d, a, b, c, w(3), 10, -1894986606);
+    c = ii(c, d, a, b, w(10), 15, -1051523);
+    b = ii(b, c, d, a, w(1), 21, -2054922799);
+    a = ii(a, b, c, d, w(8), 6, 1873313359);
+    d = ii(d, a, b, c, w(15), 10, -30611744);
+    c = ii(c, d, a, b, w(6), 15, -1560198380);
+    b = ii(b, c, d, a, w(13), 21, 1309151649);
+    a = ii(a, b, c, d, w(4), 6, -145523070);
+    d = ii(d, a, b, c, w(11), 10, -1120210379);
+    c = ii(c, d, a, b, w(2), 15, 718787259);
+    b = ii(b, c, d, a, w(9), 21, -343485551);
+    a = add(a, oa);
+    b = add(b, ob);
+    c = add(c, oc);
+    d = add(d, od);
+  }
+  const out = new Uint8Array(16);
+  [a, b, c, d].forEach((word, wi) => {
+    for (let j = 0; j < 4; j++) out[wi * 4 + j] = word >>> j * 8 & 255;
+  });
+  return out;
+}
+function md5Hex(input) {
+  return toHex(md5Bytes(input));
+}
+function sha1Bytes(input) {
+  const msg = toBytes(input);
+  const len = msg.length;
+  const withLen = len + 9;
+  const blocks = Math.ceil(withLen / 64);
+  const total = blocks * 64;
+  const buf = new Uint8Array(total);
+  buf.set(msg);
+  buf[len] = 128;
+  const bitLen = len * 8;
+  buf[total - 4] = bitLen >>> 24 & 255;
+  buf[total - 3] = bitLen >>> 16 & 255;
+  buf[total - 2] = bitLen >>> 8 & 255;
+  buf[total - 1] = bitLen & 255;
+  let h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878, h4 = -1009589776;
+  const w = new Int32Array(80);
+  const rol = (n, s) => n << s | n >>> 32 - s;
+  for (let i = 0; i < total; i += 64) {
+    for (let j = 0; j < 16; j++) {
+      const k = i + j * 4;
+      w[j] = buf[k] << 24 | buf[k + 1] << 16 | buf[k + 2] << 8 | buf[k + 3];
+    }
+    for (let j = 16; j < 80; j++) w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+    let a = h0, b = h1, c = h2, d = h3, e = h4;
+    for (let j = 0; j < 80; j++) {
+      let f, k;
+      if (j < 20) {
+        f = b & c | ~b & d;
+        k = 1518500249;
+      } else if (j < 40) {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      } else if (j < 60) {
+        f = b & c | b & d | c & d;
+        k = -1894007588;
+      } else {
+        f = b ^ c ^ d;
+        k = -899497514;
+      }
+      const t = rol(a, 5) + f + e + k + w[j] | 0;
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+  }
+  const out = new Uint8Array(20);
+  [h0, h1, h2, h3, h4].forEach((h, hi) => {
+    out[hi * 4] = h >>> 24 & 255;
+    out[hi * 4 + 1] = h >>> 16 & 255;
+    out[hi * 4 + 2] = h >>> 8 & 255;
+    out[hi * 4 + 3] = h & 255;
+  });
+  return out;
+}
+function toHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function randomBytes(n) {
+  const out = new Uint8Array(n);
+  globalThis.crypto.getRandomValues(out);
+  return out;
+}
+
+export {
+  md5Hex,
+  sha1Bytes,
+  randomBytes
+};
+//# sourceMappingURL=chunk-OHX6MIUZ.js.map

package/dist/chunk-OOXWYAA4.js

@@ -0,0 +1,15 @@
+// src/deploy/server-bundle.ts
+var SERVER_DIR = ".xano-ssr";
+var SERVER_BUNDLE = `${SERVER_DIR}/server.js`;
+var SERVER_ENV = `${SERVER_DIR}/env.json`;
+function isServerPath(path) {
+  return path === SERVER_DIR || path.startsWith(`${SERVER_DIR}/`);
+}
+
+export {
+  SERVER_DIR,
+  SERVER_BUNDLE,
+  SERVER_ENV,
+  isServerPath
+};
+//# sourceMappingURL=chunk-OOXWYAA4.js.map