@xano/sdk 1.0.0

package/dist/chunk-TLHIFK4M.js

@@ -0,0 +1,256 @@
+import {
+  classifyFailure
+} from "./chunk-A6E77GDW.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import {
+  EXIT_OUTCOME_UNKNOWN,
+  exitCodeOf,
+  explainRunFailure,
+  failureError,
+  processExitCode,
+  registerOperation,
+  warn,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/operation-result.ts
+var SERVER_PROCESSING_BOUND_MS = 6e5;
+function rollUp(steps) {
+  const ran = steps.filter((s) => s !== "skipped");
+  if (ran.length === 0) return "no";
+  if (ran.includes("no")) return "no";
+  if (ran.includes("unknown")) return "unknown";
+  return "yes";
+}
+var OperationBuilder = class {
+  operation;
+  startedAt;
+  destination;
+  release;
+  branch;
+  residue;
+  extras;
+  order;
+  checks;
+  state = /* @__PURE__ */ new Map();
+  current;
+  now;
+  /** Attached by {@link runOperation}, so `sending()` reaches the interrupt path. */
+  registration;
+  constructor(init) {
+    this.operation = init.operation;
+    this.destination = "instance" in init.destination ? { ...init.destination } : writeTargetPayload(init.destination);
+    this.release = { ...init.release };
+    this.branch = init.branch;
+    this.extras = { ...init.extras ?? {} };
+    this.order = [...init.steps];
+    this.checks = new Set(init.checks ?? []);
+    for (const s of this.order) this.state.set(s, {});
+    this.now = init.now ?? Date.now;
+    this.startedAt = this.now();
+  }
+  stepState(step) {
+    const st = this.state.get(step);
+    if (st === void 0) {
+      throw new Error(
+        `"${step}" is not a requested step of ${this.operation} (${this.order.join(", ")}).`
+      );
+    }
+    return st;
+  }
+  /** The release as the server stored it, once it says. */
+  setRelease(release) {
+    this.release = { ...release };
+  }
+  setBranch(branch) {
+    this.branch = branch;
+  }
+  /** Record what a failed write left behind, and the command that removes it. */
+  setResidue(residue) {
+    this.residue = residue === void 0 ? void 0 : { ...residue };
+  }
+  /** Set an operation-specific extra. */
+  set(key, value) {
+    this.extras[key] = value;
+  }
+  /** Enter a step. A throw from here on is attributed to it. */
+  begin(step) {
+    this.stepState(step);
+    this.current = step;
+  }
+  /**
+   * The current step's write is about to go on the wire. Call immediately
+   * BEFORE sending it: from here a failure of this step is classified as a
+   * possibly-landed write, and Ctrl-C reports it `unknown` instead of
+   * "Cancelled.".
+   */
+  sending() {
+    if (this.current === void 0)
+      throw new Error(
+        "sending() called outside a step; call begin(step) first."
+      );
+    this.stepState(this.current).sentAt = this.now();
+    this.registration?.markWriteSent();
+  }
+  /**
+   * Record a step's answer (default `yes`). A step never begun may be recorded
+   * directly — `skipped` for one the command had no need to run (a transfer
+   * that found its release already at the destination imports nothing).
+   */
+  finish(step, completed = "yes") {
+    this.stepState(step).completed = completed;
+    if (this.current === step) this.current = void 0;
+  }
+  /** The step entered and not yet finished, if any. */
+  get inProgress() {
+    return this.current;
+  }
+  /** Whether the step in progress has sent its write. */
+  get inProgressSent() {
+    return this.current !== void 0 && this.stepState(this.current).sentAt !== void 0;
+  }
+  /**
+   * The result as it stands.
+   *
+   * Steps are resolved in this order: a recorded answer wins; the step in
+   * progress takes the interrupt's or the throw's outcome (or, at a normal
+   * return, `unknown` if its write was sent and `no` if not); a step never
+   * reached after one that stopped the run is `skipped`; any other step never
+   * reached is `no` — it did not happen, and nothing explains why.
+   */
+  snapshot(ctx = {}) {
+    let latestUnknownSend;
+    let halted;
+    const stop = (name, completed) => {
+      halted ??= this.checks.has(name) && completed === "unknown" ? "uncarried" : "carried";
+    };
+    const steps = this.order.map((name) => {
+      const st = this.stepState(name);
+      let completed;
+      if (st.completed !== void 0) {
+        completed = st.completed;
+        if (completed === "no" || completed === "unknown") stop(name, completed);
+      } else if (name === this.current) {
+        completed = ctx.interrupted ? "unknown" : ctx.failure ?? (st.sentAt !== void 0 ? "unknown" : "no");
+        stop(name, completed);
+      } else {
+        completed = halted === "carried" ? "skipped" : "no";
+      }
+      if (completed === "unknown" && !this.checks.has(name)) {
+        const at = st.sentAt ?? this.startedAt;
+        latestUnknownSend = latestUnknownSend === void 0 ? at : Math.max(latestUnknownSend, at);
+      }
+      return { name, completed };
+    });
+    const core = {
+      operation: this.operation,
+      destination: this.destination,
+      release: this.release,
+      branch: this.branch,
+      // A check that could not run leaves the outcome as it was; see `checks`.
+      completed: rollUp(
+        steps.map(
+          (s) => this.checks.has(s.name) && s.completed === "unknown" ? "skipped" : s.completed
+        )
+      ),
+      steps,
+      startedAt: new Date(this.startedAt).toISOString()
+    };
+    if (this.residue !== void 0) core.residue = this.residue;
+    const resolveWith = ctx.resolveWith ?? this.registration?.resolveWith;
+    if (latestUnknownSend !== void 0 && resolveWith !== void 0) {
+      core.resolveWith = resolveWith;
+      core.resolveNotBefore = new Date(
+        latestUnknownSend + SERVER_PROCESSING_BOUND_MS
+      ).toISOString();
+    }
+    return { ...core, ...this.extras };
+  }
+};
+function createOperation(init) {
+  return new OperationBuilder(init);
+}
+var OperationError = class extends Error {
+  constructor(message, exitCode, result, options) {
+    super(message, options);
+    this.exitCode = exitCode;
+    this.result = result;
+  }
+  exitCode;
+  result;
+  name = "OperationError";
+};
+async function runOperation(op, opts, body) {
+  const registration = registerOperation({
+    machine: opts.machine,
+    resolveWith: opts.resolveWith,
+    ...opts.what === void 0 ? {} : { what: opts.what },
+    snapshot: ({ interrupted }) => op.snapshot({ interrupted })
+  });
+  op.registration = registration;
+  let failure;
+  let outcome;
+  try {
+    await describeWrite(
+      { ...opts.what === void 0 ? {} : { what: opts.what }, resolveWith: opts.resolveWith },
+      () => body(op)
+    );
+  } catch (caught) {
+    const err2 = await explainRunFailure(caught);
+    failure = { err: err2 };
+    outcome = classifyFailure(err2, { writeSent: op.inProgressSent });
+  }
+  let result;
+  try {
+    result = op.snapshot({
+      ...outcome === void 0 ? {} : { failure: outcome },
+      resolveWith: opts.resolveWith
+    });
+  } finally {
+    registration.clear();
+    op.registration = void 0;
+  }
+  const unresolved = result.resolveWith !== void 0;
+  if (unresolved && opts.resolveSteps !== void 0) {
+    const { resolveNotBefore, ...rest } = result;
+    result = { ...rest, resolveSteps: [...opts.resolveSteps], resolveNotBefore };
+  }
+  const err = failure?.err;
+  const own = exitCodeOf(err);
+  const statedUnknown = failure !== void 0 && ownExitCode(err) === void 0 && processExitCode(err) === EXIT_OUTCOME_UNKNOWN;
+  const code = unresolved || statedUnknown ? EXIT_OUTCOME_UNKNOWN : ownExitCode(err) ?? opts.exitCode ?? 1;
+  const message = failure === void 0 ? `${op.operation} did not complete: ${result.steps.filter((s) => s.completed !== "yes").map((s) => `${s.name} ${s.completed}`).join(", ")}.` : err instanceof Error ? err.message : String(err);
+  if (failure !== void 0) {
+    result = { ok: false, ...result, error: failureError(err, message, code) };
+  }
+  if (opts.machine) writeJson(result);
+  if (unresolved) {
+    warn(
+      `Outcome unknown \u2014 check with \`${result.resolveWith}\` before retrying. An "absent" answer before ${result.resolveNotBefore} is not proof: the server may still be finishing the write.`,
+      "operation.outcome-unknown",
+      opts.resolveSteps
+    );
+  }
+  if (failure === void 0 && result.completed === "yes") return result;
+  if (failure !== void 0 && code === own) throw err;
+  throw new OperationError(
+    message,
+    code,
+    result,
+    failure === void 0 ? void 0 : { cause: err }
+  );
+}
+function ownExitCode(err) {
+  const code = err?.exitCode;
+  return typeof code === "number" ? exitCodeOf(err) : void 0;
+}
+
+export {
+  createOperation,
+  OperationError,
+  runOperation
+};
+//# sourceMappingURL=chunk-TLHIFK4M.js.map

package/dist/chunk-TLQE7ZN3.js

@@ -0,0 +1,156 @@
+import {
+  LOCK_PAYLOAD_KEYS,
+  lockKey
+} from "./chunk-6MR5TI5V.js";
+
+// src/lock/landed.ts
+function destinationKey(instance, dest) {
+  let host;
+  try {
+    host = new URL(instance).host.toLowerCase();
+  } catch {
+    host = instance.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "").toLowerCase();
+  }
+  return dest.kind === "workspace" ? `${host}/workspace/${dest.workspaceId}` : `${host}/${dest.kind}/${dest.name}`;
+}
+function isEphemeralDestinationKey(key) {
+  return /^[^/\s]+\/ephemeral\/[^/\s]+$/.test(key);
+}
+function groupNames(payload) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const section of ["app", "realtime_server", "channel"]) {
+    const rows = payload[section];
+    for (const g of Array.isArray(rows) ? rows : []) {
+      if (g === null || typeof g !== "object") continue;
+      const { name, guid, id } = g;
+      if (typeof name !== "string") continue;
+      if (typeof guid === "string" && guid !== "") groups.set(guid, name);
+      if (typeof id === "number" && id !== 0) groups.set(`${section}#${id}`, name);
+    }
+  }
+  return groups;
+}
+function landedKeyForRow(payloadKey, row, groups) {
+  if (typeof row.name !== "string" || row.name === "") return void 0;
+  const parent = (ref, section) => {
+    const id = ref?.id;
+    if (typeof id === "string" && id !== "") return groups.get(id) ?? id;
+    return typeof id === "number" && id !== 0 ? groups.get(`${section}#${id}`) ?? `#${id}` : "";
+  };
+  if (payloadKey === "channel") return lockKey(payloadKey, [parent(row.server, "realtime_server"), row.name].join("|"));
+  if (payloadKey === "message") {
+    return lockKey(payloadKey, [parent(row.server, "realtime_server"), parent(row.channel, "channel"), row.name].join("|"));
+  }
+  if (payloadKey !== "query") return lockKey(payloadKey, row.name);
+  const verb = typeof row.verb === "string" ? row.verb : "";
+  const appId = row.app?.id;
+  const group = appId === void 0 || appId === null || appId === 0 || appId === "" ? "" : groups.get(typeof appId === "number" ? `app#${appId}` : appId) ?? "";
+  return lockKey("query", [group, verb, row.name].join("|"));
+}
+function landedIdentities(bundle) {
+  const payload = bundle?.payload;
+  const out = {};
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return out;
+  const sections = payload;
+  const groups = groupNames(sections);
+  for (const payloadKey of LOCK_PAYLOAD_KEYS) {
+    const rows = sections[payloadKey];
+    if (!Array.isArray(rows)) continue;
+    for (const row of rows) {
+      if (row === null || typeof row !== "object") continue;
+      const r = row;
+      if (typeof r.guid !== "string" || r.guid === "") continue;
+      const key = landedKeyForRow(payloadKey, r, groups);
+      if (key === void 0) continue;
+      out[key] = payloadKey === "toolset" && r.type === "agent" ? { guid: r.guid, type: "agent" } : { guid: r.guid };
+    }
+  }
+  return out;
+}
+function identitiesMatchLock(identities, lock) {
+  const keys = Object.keys(identities);
+  if (keys.length === 0) return false;
+  return keys.every((key) => {
+    const entry = lock.objects[key];
+    if (entry?.guid !== identities[key].guid) return false;
+    return !key.startsWith("toolset:") || entry.type === "agent" === (identities[key].type === "agent");
+  });
+}
+function applyLanding(lock, destKey, update) {
+  const next = nextLandedRecord(lock.landed?.[destKey] ?? {}, update);
+  const landed = { ...lock.landed ?? {} };
+  if (Object.keys(next).length > 0) landed[destKey] = next;
+  else delete landed[destKey];
+  const objects = withoutPrunedObjects(lock.objects, update);
+  return Object.keys(landed).length > 0 ? { version: lock.version, objects, landed } : { version: lock.version, objects };
+}
+function withoutPrunedObjects(objects, update) {
+  const drop = Object.entries(update.removed ?? {}).filter(
+    ([key, entry]) => objects[key]?.guid === entry.guid && update.identities[key] === void 0
+  );
+  if (drop.length === 0) return objects;
+  const kept = { ...objects };
+  for (const [key] of drop) delete kept[key];
+  return kept;
+}
+function nextLandedRecord(before, update) {
+  let next;
+  if (update.mode === "replace") {
+    next = { ...update.identities };
+  } else {
+    const landingGuids = new Map(Object.entries(update.identities).map(([k, e]) => [e.guid, k]));
+    next = {};
+    for (const [key, entry] of Object.entries(before)) {
+      const movedTo = landingGuids.get(entry.guid);
+      if (movedTo !== void 0 && movedTo !== key) continue;
+      next[key] = entry;
+    }
+    Object.assign(next, update.identities);
+  }
+  for (const [key, entry] of Object.entries(update.removed ?? {})) {
+    if (next[key]?.guid === entry.guid) delete next[key];
+  }
+  return next;
+}
+function storedColumnsOf(record) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, entry] of Object.entries(record ?? {})) {
+    if (key.startsWith("dbo:") && entry.columns !== void 0) out.set(entry.guid, entry.columns);
+  }
+  return out;
+}
+function withStoredColumns(identities, stored) {
+  if (stored === void 0) return identities;
+  const out = {};
+  for (const [key, entry] of Object.entries(identities)) {
+    const columns = key.startsWith("dbo:") ? stored.get(entry.guid) : void 0;
+    out[key] = columns === void 0 ? entry : { ...entry, columns: { ...columns } };
+  }
+  return out;
+}
+function withoutLanding(lock, destKey) {
+  if (lock.landed?.[destKey] === void 0) return lock;
+  const { [destKey]: _dropped, ...landed } = lock.landed;
+  return Object.keys(landed).length > 0 ? { version: lock.version, objects: lock.objects, landed } : { version: lock.version, objects: lock.objects };
+}
+function landedOn(lock, destKey) {
+  const record = lock.landed?.[destKey];
+  return record === void 0 || Object.keys(record).length === 0 ? void 0 : record;
+}
+
+export {
+  destinationKey,
+  isEphemeralDestinationKey,
+  groupNames,
+  landedKeyForRow,
+  landedIdentities,
+  identitiesMatchLock,
+  applyLanding,
+  withoutPrunedObjects,
+  nextLandedRecord,
+  storedColumnsOf,
+  withStoredColumns,
+  withoutLanding,
+  landedOn
+};
+//# sourceMappingURL=chunk-TLQE7ZN3.js.map