@conto_finance/sdk 0.5.4 → 0.6.0-beta.1

package/dist/link-testing.mjs

@@ -0,0 +1,244 @@
+import "./chunk-WSIKPUZJ.mjs";
+
+// src/link-testing.ts
+import { randomUUID } from "crypto";
+import {
+  ContoError,
+  LinkClient
+} from "./index.mjs";
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => `${JSON.stringify(key)}:${canonical(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function fail(code, message, status = 409) {
+  throw new ContoError(message, { code, status });
+}
+function createLinkTestClient(options = {}) {
+  const scenario = options.scenario ?? "approved";
+  const maximumAmountMinor = options.maximumAmountMinor ?? 5e3;
+  if (!["approved", "denied", "expired", "interrupted"].includes(scenario) || !Number.isSafeInteger(maximumAmountMinor) || maximumAmountMinor <= 0) {
+    throw new ContoError("Invalid Link simulation options", {
+      code: "INVALID_LINK_TEST_OPTIONS",
+      status: 0
+    });
+  }
+  const records = /* @__PURE__ */ new Map();
+  const intents = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const sessionId = randomUUID();
+  const read = (id) => {
+    const record = records.get(id);
+    if (!record)
+      return fail(
+        "SIMULATED_EXECUTION_NOT_FOUND",
+        "No such execution in this local simulation",
+        404
+      );
+    return record;
+  };
+  const response = (id) => ({
+    execution: structuredClone(read(id))
+  });
+  const setStatus = (id, status) => {
+    const record = read(id);
+    record.status = status;
+    record.evidence.status = status;
+    record.providerStatus = `SIMULATED_${status}`;
+    record.evidence.providerStatus = record.providerStatus;
+    delete record.approvalUrl;
+    return response(id);
+  };
+  const setup = async (_input = {}) => ({
+    version: "conto.link-setup.v1",
+    mode: "SIMULATED",
+    configurationStatus: "CONFIGURED",
+    checks: [
+      {
+        code: "LOCAL_SIMULATION",
+        status: "WARNING",
+        actor: "developer",
+        message: "Local workflow fixture only. No real Link account, Conto policy, checkout, budget, or settlement is tested."
+      }
+    ],
+    missingScopes: [],
+    paymentAuthorization: "NOT_EVALUATED",
+    providerVerified: false,
+    settlementVerified: false
+  });
+  const transport = {
+    getLinkSetup: setup,
+    async listStripeLinkPaymentMethods() {
+      return {
+        organizationId: "simulated_org",
+        connectionId: "simulated_connection",
+        paymentMethods: [
+          {
+            id: "simulated_method",
+            type: "SIMULATED",
+            isDefault: true,
+            displayLabel: "Simulated funding source \u2014 no funds",
+            eligibleCredentialTypes: ["LINK_PAY_TOKEN"]
+          }
+        ]
+      };
+    },
+    async beginCommerceExecution(input) {
+      if (input.executionMethod !== "LINK_PAY_TOKEN")
+        return fail(
+          "SIMULATED_METHOD_UNSUPPORTED",
+          "Only the Link Pay Token workflow is simulated"
+        );
+      const key = input.idempotencyKey?.trim();
+      if (!key || key.length < 8 || key.length > 255) {
+        return fail(
+          "INVALID_IDEMPOTENCY_KEY",
+          "idempotencyKey must contain 8 to 255 characters",
+          0
+        );
+      }
+      const fingerprint = canonical({ ...input, idempotencyKey: key });
+      const prior = intents.get(key);
+      if (prior) {
+        if (prior.fingerprint !== fingerprint)
+          return fail("IDEMPOTENCY_CONFLICT", "The key belongs to a different simulated purchase");
+        return response(prior.id);
+      }
+      if (scenario === "denied" || input.amountMinor > maximumAmountMinor) {
+        return fail(
+          "COMMERCE_POLICY_DENIED",
+          "The local simulated policy denied this purchase",
+          403
+        );
+      }
+      if (records.size >= 1e3)
+        return fail(
+          "SIMULATION_CAPACITY_REACHED",
+          "Create a new test client to start another simulation"
+        );
+      const id = `sim_link_${sessionId}_${++sequence}`;
+      const status = "AWAITING_APPROVAL";
+      const evidence = {
+        schemaVersion: "conto.commerce-evidence.v1",
+        traceId: `sim_trace_${sequence}`,
+        executionId: id,
+        intentId: `sim_intent_${sequence}`,
+        organizationId: "simulated_org",
+        actorUserId: "simulated_owner",
+        agentId: "simulated_agent",
+        provider: "STRIPE_LINK",
+        sourceKind: "STRIPE_LINK",
+        amountMinor: input.amountMinor,
+        currency: input.currency,
+        purpose: input.purpose,
+        counterpartyId: input.counterparty.canonicalId,
+        counterpartyName: "Simulated checkout",
+        intentFingerprint: `sim_fingerprint_${sequence}`,
+        policyDecisionId: `sim_policy_${sequence}`,
+        policySnapshotHash: "simulated_policy",
+        grantId: `sim_grant_${sequence}`,
+        status,
+        deliveryMode: "SERVER_ONLY_ARTIFACT",
+        artifactKind: "LINK_PAY_TOKEN",
+        providerStatus: "SIMULATED_AWAITING_APPROVAL"
+      };
+      records.set(id, {
+        id,
+        intentId: evidence.intentId,
+        organizationId: evidence.organizationId,
+        agentId: evidence.agentId,
+        provider: "STRIPE_LINK",
+        executionAdapter: "STRIPE_LINK",
+        executionChannel: "BROWSER",
+        checkoutMethod: "LINK",
+        status,
+        providerStatus: evidence.providerStatus,
+        artifactKind: "LINK_PAY_TOKEN",
+        deliveryMode: "SERVER_ONLY_ARTIFACT",
+        // Reserved .invalid domain. It cannot approve anything; call the test-only approve() method.
+        approvalUrl: `https://link-simulation.invalid/approve/${id}`,
+        amountMinor: input.amountMinor,
+        currency: input.currency,
+        purpose: input.purpose,
+        counterparty: { id: input.counterparty.canonicalId, name: "Simulated checkout" },
+        evidence,
+        evidenceFingerprint: `sim_evidence_${sequence}`
+      });
+      intents.set(key, { fingerprint, id });
+      return response(id);
+    },
+    async getCommerceExecution(id) {
+      return response(id);
+    },
+    async refreshCommerceExecution(id) {
+      return response(id);
+    },
+    async executeCommerceExecution(id) {
+      if (read(id).status !== "READY")
+        return fail("COMMERCE_EXECUTION_NOT_READY", "The simulated payment is not ready");
+      if (scenario === "interrupted") {
+        setStatus(id, "NEEDS_RECONCILIATION");
+        return fail(
+          "SIMULATED_EXECUTION_INTERRUPTED",
+          "Simulated lost execution response; inspect the existing execution",
+          0
+        );
+      }
+      return {
+        ...setStatus(id, "COMPLETED"),
+        checkout: {
+          submitted: false,
+          accepted: false,
+          deliveryMode: "SERVER_ONLY_ARTIFACT"
+        }
+      };
+    },
+    async cancelCommerceExecution(id) {
+      if (["PROCESSING", "NEEDS_RECONCILIATION", "COMPLETED", "SETTLED"].includes(read(id).status)) {
+        return fail(
+          "SIMULATED_CANCELLATION_UNAVAILABLE",
+          "This simulated execution must be reconciled and cannot be cancelled"
+        );
+      }
+      return setStatus(id, "CANCELLED");
+    }
+  };
+  const client = new LinkClient(transport, {
+    connectionId: "simulated_connection",
+    paymentMethodId: "simulated_method"
+  });
+  const marked = async (operation) => {
+    try {
+      return { ...await operation(), mode: "SIMULATED", settlementVerified: false };
+    } catch (error) {
+      const safe = error instanceof ContoError ? error : new ContoError("Local simulation failed", { code: "SIMULATION_FAILED", status: 0 });
+      throw Object.assign(safe, { mode: "SIMULATED", settlementVerified: false });
+    }
+  };
+  return {
+    mode: "SIMULATED",
+    link: {
+      setup: (input) => marked(() => client.setup(input)),
+      paymentMethods: () => marked(() => client.paymentMethods()),
+      pay: (input) => marked(() => client.pay(input)),
+      resume: (id) => marked(() => client.resume(id)),
+      status: (id) => marked(() => client.status(id)),
+      cancel: (id) => marked(() => client.cancel(id)),
+      /** Test-only owner action. Never available on the live Link client. */
+      approve: (id) => marked(async () => {
+        if (read(id).status !== "AWAITING_APPROVAL")
+          return fail(
+            "SIMULATED_APPROVAL_UNAVAILABLE",
+            "This simulation is not awaiting approval"
+          );
+        setStatus(id, scenario === "expired" ? "EXPIRED" : "READY");
+        return client.status(id);
+      })
+    }
+  };
+}
+export {
+  createLinkTestClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@conto_finance/sdk",
-  "version": "0.5.4",
+  "version": "0.6.0-beta.1",
   "description": "Conto SDK for AI agent payment authorization",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -25,10 +25,16 @@
       "types": "./dist/checkout-verifier.d.ts",
       "import": "./dist/checkout-verifier.mjs",
       "require": "./dist/checkout-verifier.js"
+    },
+    "./link-testing": {
+      "types": "./dist/link-testing.d.ts",
+      "import": "./dist/link-testing.mjs",
+      "require": "./dist/link-testing.js"
     }
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "beta"
   },
   "engines": {
     "node": ">=20.19.0"
@@ -37,11 +43,11 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/playwright.ts src/browserbase.ts src/checkout-verifier.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts src/playwright.ts src/browserbase.ts src/checkout-verifier.ts --format cjs,esm --dts --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "lint": "tsc --noEmit",
     "test": "npm run lint && npm run test:contract && npm run test:consumer",
-    "test:contract": "npm run build && node --test test/contract.test.mjs test/playwright.test.mjs test/browserbase.test.mjs test/checkout-verifier.test.mjs test/developer-experience.test.mjs",
+    "test:contract": "npm run build && node --test test/contract.test.mjs test/playwright.test.mjs test/browserbase.test.mjs test/checkout-verifier.test.mjs test/developer-experience.test.mjs test/link.test.mjs test/link-testing.test.mjs",
     "test:consumer": "npm run build && node --test test/consumer.test.mjs",
     "verify:release": "node scripts/verify-release.mjs",
     "prepublishOnly": "npm run verify:release && npm run lint && npm run test:contract && npm run test:consumer"