xytara 1.0.0

package/lib/commerce_runtime.js

@@ -0,0 +1,215 @@
+"use strict";
+
+const { createCommandArtifacts } = require("./commerce_artifacts");
+const { createQuote, hydrateQuoteStates, markQuoteExecuted } = require("./commerce_quotes");
+const { listRecords } = require("./record_queries");
+const {
+  actOnDispute,
+  actOnRefund,
+  actOnRemediationTicket,
+  createDispute,
+  createRefund,
+  createRemediationTicket
+} = require("./commerce_cases");
+
+function createRuntimeState() {
+  return {
+    quotes: new Map(),
+    transactions: new Map(),
+    receipts: new Map(),
+    paymentLedger: [],
+    deliveries: new Map(),
+    pendingExecutions: new Map(),
+    disputes: new Map(),
+    refunds: new Map(),
+    remediationTickets: new Map()
+  };
+}
+
+function buildDeliveryEvent(event, delivery, atIso, extra) {
+  return {
+    event,
+    at_iso: atIso,
+    status: delivery.status,
+    callback_url: delivery.callback_url || null,
+    output_ref: delivery.output_ref || null,
+    proof_ref: delivery.proof_ref || null,
+    ...(extra || {})
+  };
+}
+
+function completePendingExecution(state, transactionId) {
+  if (!transactionId || !state.pendingExecutions.has(transactionId) || !state.transactions.has(transactionId)) {
+    return state.transactions.get(transactionId) || null;
+  }
+  const pending = state.pendingExecutions.get(transactionId);
+  const current = state.transactions.get(transactionId);
+  if (!pending || !current || Date.now() < pending.readyAtMs) {
+    return current;
+  }
+
+  const completedAtIso = new Date(pending.readyAtMs).toISOString();
+  const next = {
+    transaction: {
+      ...current.transaction,
+      status: "completed",
+      completed_at_iso: completedAtIso,
+      timing: {
+        ...current.transaction.timing,
+        completed_at_iso: completedAtIso,
+        duration_ms: pending.durationMs,
+        observed_latency_class: pending.observedLatencyClass,
+        assessment: pending.assessment
+      },
+      execution: {
+        ...current.transaction.execution,
+        status: "completed"
+      },
+      remediation: {
+        ...current.transaction.remediation,
+        updated_at_iso: completedAtIso
+      }
+    },
+    receipt: {
+      ...current.receipt,
+      status: "completed",
+      created_at_iso: completedAtIso,
+      timing: {
+        ...current.receipt.timing,
+        completed_at_iso: completedAtIso,
+        duration_ms: pending.durationMs,
+        observed_latency_class: pending.observedLatencyClass,
+        assessment: pending.assessment
+      },
+      remediation: {
+        ...current.receipt.remediation,
+        updated_at_iso: completedAtIso
+      }
+    },
+    command: current.command
+  };
+
+  state.transactions.set(transactionId, next);
+  state.receipts.set(next.receipt.receipt_id, next);
+  if (pending.quoteId && state.quotes.has(pending.quoteId)) {
+    const quote = state.quotes.get(pending.quoteId);
+    state.quotes.set(pending.quoteId, {
+      ...quote,
+      status: "executed",
+      payment_recorded_at_iso: completedAtIso,
+      executed_at_iso: completedAtIso
+    });
+  }
+  if (pending.deliveryId && state.deliveries.has(pending.deliveryId)) {
+    const delivery = state.deliveries.get(pending.deliveryId);
+    const nextDelivery = {
+      ...delivery,
+      status: "delivered",
+      delivered_at_iso: completedAtIso,
+      receipt_id: next.receipt.receipt_id,
+      proof_ref: next.receipt.proof_ref,
+      attempt_count: (delivery.attempt_count || 0) + 1,
+      last_attempt_at_iso: completedAtIso,
+      history: [
+        ...(Array.isArray(delivery.history) ? delivery.history : []),
+        buildDeliveryEvent("delivered", { ...delivery, status: "delivered", proof_ref: next.receipt.proof_ref }, completedAtIso, {
+          attempt_number: (delivery.attempt_count || 0) + 1
+        })
+      ]
+    };
+    state.deliveries.set(pending.deliveryId, nextDelivery);
+  }
+  state.pendingExecutions.delete(transactionId);
+  return next;
+}
+
+function hydratePendingExecutions(state) {
+  for (const transactionId of Array.from(state.pendingExecutions.keys())) {
+    completePendingExecution(state, transactionId);
+  }
+}
+
+function createCommandResult(state, payload, quote) {
+  const deferredCompletion = payload && payload.defer_completion === true;
+  const { transaction, receipt, command } = createCommandArtifacts(payload, quote, { deferredCompletion });
+  const result = { transaction, receipt, command };
+  state.transactions.set(transaction.transaction_id, result);
+  state.receipts.set(receipt.receipt_id, result);
+  const paymentRecord = {
+    payment_id: `pay_${quote.quote_id}`,
+    quote_id: quote.quote_id,
+    transaction_id: transaction.transaction_id,
+    receipt_id: receipt.receipt_id,
+    account_id: quote.account_id,
+    amount_minor: quote.amount_minor,
+    currency: quote.currency,
+    settlement_adapter: quote.settlement_adapter,
+    recorded_at_iso: receipt.created_at_iso
+  };
+  state.paymentLedger = [
+    paymentRecord,
+    ...(Array.isArray(state.paymentLedger) ? state.paymentLedger : [])
+  ].slice(0, 100);
+  const deliveryRecord = {
+    delivery_id: `delivery_${transaction.transaction_id}`,
+    transaction_id: transaction.transaction_id,
+    receipt_id: receipt.receipt_id,
+    quote_id: quote.quote_id,
+    account_id: quote.account_id,
+    callback_url: transaction.callback_url,
+    output_ref: transaction.output_ref,
+    proof_ref: receipt.proof_ref,
+    payment_id: paymentRecord.payment_id,
+    delivery_target_kind: transaction.callback_url ? "callback" : "direct",
+    status: deferredCompletion ? "pending_delivery" : "delivered",
+    created_at_iso: transaction.created_at_iso,
+    delivered_at_iso: deferredCompletion ? null : receipt.created_at_iso,
+    attempt_count: deferredCompletion ? 0 : 1,
+    last_attempt_at_iso: deferredCompletion ? null : receipt.created_at_iso,
+    history: [
+      buildDeliveryEvent("created", {
+        callback_url: transaction.callback_url,
+        output_ref: transaction.output_ref,
+        proof_ref: receipt.proof_ref,
+        status: deferredCompletion ? "pending_delivery" : "delivered"
+      }, transaction.created_at_iso),
+      ...(!deferredCompletion ? [
+        buildDeliveryEvent("delivered", {
+          callback_url: transaction.callback_url,
+          output_ref: transaction.output_ref,
+          proof_ref: receipt.proof_ref,
+          status: "delivered"
+        }, receipt.created_at_iso, { attempt_number: 1 })
+      ] : [])
+    ]
+  };
+  state.deliveries.set(deliveryRecord.delivery_id, deliveryRecord);
+  markQuoteExecuted(state, quote, result, paymentRecord, { deferredCompletion });
+  if (deferredCompletion) {
+    state.pendingExecutions.set(transaction.transaction_id, {
+      readyAtMs: Date.now() + 300,
+      quoteId: quote.quote_id,
+      deliveryId: deliveryRecord.delivery_id,
+      durationMs: 250,
+      observedLatencyClass: "instant",
+      assessment: "within_posture"
+    });
+  }
+  return result;
+}
+
+module.exports = {
+  completePendingExecution,
+  createCommandResult,
+  createDispute,
+  createQuote,
+  createRefund,
+  createRemediationTicket,
+  createRuntimeState,
+  hydrateQuoteStates,
+  hydratePendingExecutions,
+  actOnDispute,
+  actOnRefund,
+  actOnRemediationTicket,
+  listRecords
+};

package/lib/http_transport.js

@@ -0,0 +1,40 @@
+"use strict";
+
+function sendJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > 1024 * 1024) {
+        reject(new Error("request body too large"));
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      if (!body) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(body));
+      } catch (error) {
+        reject(new Error("body must be valid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+module.exports = {
+  readJsonBody,
+  sendJson
+};

package/lib/record_queries.js

@@ -0,0 +1,47 @@
+"use strict";
+
+function listRecords(map, filters) {
+  const entries = Array.from(map.values());
+  const opts = filters || {};
+  let items = entries;
+  if (opts.status) items = items.filter((item) => item.status === opts.status);
+  if (opts.account_id) items = items.filter((item) => item.account_id === opts.account_id);
+  if (opts.quote_id) items = items.filter((item) => item.quote_id === opts.quote_id);
+  if (opts.transaction_id) items = items.filter((item) => item.transaction_id === opts.transaction_id);
+  if (opts.receipt_id) items = items.filter((item) => item.receipt_id === opts.receipt_id);
+  if (opts.intent) items = items.filter((item) => item.intent === opts.intent);
+  if (opts.callback_url) items = items.filter((item) => item.callback_url === opts.callback_url);
+  if (opts.proof_ref) items = items.filter((item) => item.proof_ref === opts.proof_ref);
+  if (opts.payment_id) items = items.filter((item) => item.payment_id === opts.payment_id);
+  if (opts.currency) items = items.filter((item) => item.currency === opts.currency);
+  if (opts.settlement_adapter) {
+    items = items.filter((item) => item.settlement_adapter === opts.settlement_adapter || item.settlement_mode === opts.settlement_adapter);
+  }
+  if (opts.reason_code) items = items.filter((item) => item.reason_code === opts.reason_code);
+  if (opts.action_code) items = items.filter((item) => item.action_code === opts.action_code);
+  if (opts.assigned_owner) items = items.filter((item) => item.assigned_owner === opts.assigned_owner);
+  if (opts.actor_role) {
+    items = items.filter((item) => {
+      if (item && item.created_actor && item.created_actor.role === opts.actor_role) {
+        return true;
+      }
+      const history = Array.isArray(item && item.history) ? item.history : [];
+      return history.some((event) => event && event.actor && event.actor.role === opts.actor_role);
+    });
+  }
+  if (opts.context_source) {
+    items = items.filter((item) => {
+      if (item && item.created_context && item.created_context.source === opts.context_source) {
+        return true;
+      }
+      const history = Array.isArray(item && item.history) ? item.history : [];
+      return history.some((event) => event && event.context && event.context.source === opts.context_source);
+    });
+  }
+  const limit = Math.max(1, Math.min(Number(opts.limit || 20), 100));
+  return items.slice(0, limit);
+}
+
+module.exports = {
+  listRecords
+};

package/lib/resource_views.js

@@ -0,0 +1,31 @@
+"use strict";
+
+function buildMissingResponse(reason) {
+  return {
+    status: 404,
+    payload: { ok: false, reason }
+  };
+}
+
+function buildNamedRecordResponse(key, record, missingReason) {
+  if (!record) {
+    return buildMissingResponse(missingReason);
+  }
+  return {
+    status: 200,
+    payload: { ok: true, [key]: record }
+  };
+}
+
+function buildNamedRecordListResponse(key, records) {
+  return {
+    status: 200,
+    payload: { ok: true, [key]: records }
+  };
+}
+
+module.exports = {
+  buildMissingResponse,
+  buildNamedRecordListResponse,
+  buildNamedRecordResponse
+};

package/lib/route_matchers.js

@@ -0,0 +1,34 @@
+"use strict";
+
+function isDisputeDetailPath(pathname) {
+  return /^\/v1\/disputes\/[^/]+$/.test(pathname);
+}
+
+function isDisputeActionPath(pathname) {
+  return /^\/v1\/disputes\/[^/]+\/actions$/.test(pathname);
+}
+
+function isRefundDetailPath(pathname) {
+  return /^\/v1\/refunds\/[^/]+$/.test(pathname);
+}
+
+function isRefundActionPath(pathname) {
+  return /^\/v1\/refunds\/[^/]+\/actions$/.test(pathname);
+}
+
+function isRemediationTicketDetailPath(pathname) {
+  return /^\/v1\/remediation-tickets\/[^/]+$/.test(pathname);
+}
+
+function isRemediationTicketActionPath(pathname) {
+  return /^\/v1\/remediation-tickets\/[^/]+\/actions$/.test(pathname);
+}
+
+module.exports = {
+  isDisputeActionPath,
+  isDisputeDetailPath,
+  isRefundActionPath,
+  isRefundDetailPath,
+  isRemediationTicketActionPath,
+  isRemediationTicketDetailPath
+};

package/lib/route_params.js

@@ -0,0 +1,19 @@
+"use strict";
+
+function getQueryFilters(url) {
+  return Object.fromEntries(url.searchParams.entries());
+}
+
+function getDecodedSuffixId(pathname, prefix) {
+  return decodeURIComponent(pathname.replace(prefix, ""));
+}
+
+function getDecodedActionTargetId(pathname, prefix) {
+  return decodeURIComponent(pathname.replace("/actions", "").replace(prefix, ""));
+}
+
+module.exports = {
+  getDecodedActionTargetId,
+  getDecodedSuffixId,
+  getQueryFilters
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "xytara",
+  "version": "1.0.0",
+  "description": "Machine commerce SDK for discovery, quoting, execution, lifecycle inspection, and adapters.",
+  "main": "index.js",
+  "type": "commonjs",
+  "license": "Apache-2.0",
+  "homepage": "https://xytara.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/naxytra/xytara.git"
+  },
+  "bugs": {
+    "url": "https://github.com/naxytra/xytara/issues"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://xytara.com"
+  },
+  "keywords": [
+    "sdk",
+    "machine-client",
+    "catalog",
+    "workflow",
+    "payments",
+    "commerce",
+    "adapters"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "server.js",
+    "fixtures/",
+    "lib/",
+    "adapters/",
+    ".env.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "verify:package": "node scripts/verify_all.js",
+    "verify:adapters": "node scripts/verify_adapters.js",
+    "verify:examples": "node scripts/verify_examples.js",
+    "verify:service": "node scripts/verify_service.js",
+    "verify:all": "node scripts/verify_all.js && node scripts/verify_adapters.js && node scripts/verify_examples.js && node scripts/verify_service.js"
+  }
+}