@contractspec/integration.providers-impls 1.57.0 → 1.58.0

package/dist/node/impls/qdrant-vector.js

@@ -0,0 +1,78 @@
+// src/impls/qdrant-vector.ts
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+class QdrantVectorProvider {
+  client;
+  createCollectionIfMissing;
+  distance;
+  constructor(options) {
+    this.client = options.client ?? new QdrantClient({
+      url: options.url,
+      apiKey: options.apiKey,
+      ...options.clientParams
+    });
+    this.createCollectionIfMissing = options.createCollectionIfMissing ?? true;
+    this.distance = options.distance ?? "Cosine";
+  }
+  async upsert(request) {
+    if (request.documents.length === 0)
+      return;
+    const firstDocument = request.documents[0];
+    if (!firstDocument)
+      return;
+    const vectorSize = firstDocument.vector.length;
+    if (this.createCollectionIfMissing) {
+      await this.ensureCollection(request.collection, vectorSize);
+    }
+    const points = request.documents.map((document) => ({
+      id: document.id,
+      vector: document.vector,
+      payload: {
+        ...document.payload,
+        ...document.namespace ? { namespace: document.namespace } : {},
+        ...document.expiresAt ? { expiresAt: document.expiresAt.toISOString() } : {}
+      }
+    }));
+    await this.client.upsert(request.collection, {
+      wait: true,
+      points
+    });
+  }
+  async search(query) {
+    const results = await this.client.search(query.collection, {
+      vector: query.vector,
+      limit: query.topK,
+      filter: query.filter,
+      score_threshold: query.scoreThreshold,
+      with_payload: true,
+      with_vector: false
+    });
+    return results.map((item) => ({
+      id: String(item.id),
+      score: item.score,
+      payload: item.payload ?? undefined,
+      namespace: typeof item.payload === "object" && item.payload !== null ? item.payload.namespace : undefined
+    }));
+  }
+  async delete(request) {
+    await this.client.delete(request.collection, {
+      wait: true,
+      points: request.ids
+    });
+  }
+  async ensureCollection(collectionName, vectorSize) {
+    try {
+      await this.client.getCollection(collectionName);
+    } catch (_error) {
+      await this.client.createCollection(collectionName, {
+        vectors: {
+          size: vectorSize,
+          distance: this.distance
+        }
+      });
+    }
+  }
+}
+export {
+  QdrantVectorProvider
+};

package/dist/node/impls/stripe-payments.js

@@ -0,0 +1,228 @@
+// src/impls/stripe-payments.ts
+import Stripe from "stripe";
+var API_VERSION = "2026-01-28.clover";
+
+class StripePaymentsProvider {
+  stripe;
+  constructor(options) {
+    this.stripe = options.stripe ?? new Stripe(options.apiKey, {
+      apiVersion: API_VERSION
+    });
+  }
+  async createCustomer(input) {
+    const customer = await this.stripe.customers.create({
+      email: input.email,
+      name: input.name,
+      description: input.description,
+      metadata: input.metadata
+    });
+    return this.toCustomer(customer);
+  }
+  async getCustomer(customerId) {
+    const customer = await this.stripe.customers.retrieve(customerId);
+    if (customer.deleted)
+      return null;
+    return this.toCustomer(customer);
+  }
+  async createPaymentIntent(input) {
+    const intent = await this.stripe.paymentIntents.create({
+      amount: input.amount.amount,
+      currency: input.amount.currency,
+      customer: input.customerId,
+      description: input.description,
+      capture_method: input.captureMethod ?? "automatic",
+      confirmation_method: input.confirmationMethod ?? "automatic",
+      automatic_payment_methods: { enabled: true },
+      metadata: input.metadata,
+      return_url: input.returnUrl,
+      statement_descriptor: input.statementDescriptor
+    });
+    return this.toPaymentIntent(intent);
+  }
+  async capturePayment(paymentIntentId, input) {
+    const intent = await this.stripe.paymentIntents.capture(paymentIntentId, input?.amount ? { amount_to_capture: input.amount.amount } : undefined);
+    return this.toPaymentIntent(intent);
+  }
+  async cancelPaymentIntent(paymentIntentId) {
+    const intent = await this.stripe.paymentIntents.cancel(paymentIntentId);
+    return this.toPaymentIntent(intent);
+  }
+  async refundPayment(input) {
+    const refund = await this.stripe.refunds.create({
+      payment_intent: input.paymentIntentId,
+      amount: input.amount?.amount,
+      reason: mapRefundReason(input.reason),
+      metadata: input.metadata
+    });
+    const paymentIntentId = typeof refund.payment_intent === "string" ? refund.payment_intent : refund.payment_intent?.id ?? "";
+    return {
+      id: refund.id,
+      paymentIntentId,
+      amount: {
+        amount: refund.amount ?? 0,
+        currency: refund.currency?.toUpperCase() ?? "USD"
+      },
+      status: mapRefundStatus(refund.status),
+      reason: refund.reason ?? undefined,
+      metadata: this.toMetadata(refund.metadata),
+      createdAt: refund.created ? new Date(refund.created * 1000) : undefined
+    };
+  }
+  async listInvoices(query) {
+    const requestedStatus = query?.status?.[0];
+    const stripeStatus = requestedStatus && requestedStatus !== "deleted" ? requestedStatus : undefined;
+    const response = await this.stripe.invoices.list({
+      customer: query?.customerId,
+      status: stripeStatus,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((invoice) => this.toInvoice(invoice));
+  }
+  async listTransactions(query) {
+    const response = await this.stripe.charges.list({
+      customer: query?.customerId,
+      payment_intent: query?.paymentIntentId,
+      limit: query?.limit,
+      starting_after: query?.startingAfter
+    });
+    return response.data.map((charge) => ({
+      id: charge.id,
+      paymentIntentId: typeof charge.payment_intent === "string" ? charge.payment_intent : charge.payment_intent?.id,
+      amount: {
+        amount: charge.amount,
+        currency: charge.currency?.toUpperCase() ?? "USD"
+      },
+      type: "capture",
+      status: mapChargeStatus(charge.status),
+      description: charge.description ?? undefined,
+      createdAt: new Date(charge.created * 1000),
+      metadata: this.mergeMetadata(this.toMetadata(charge.metadata), {
+        balanceTransaction: typeof charge.balance_transaction === "string" ? charge.balance_transaction : undefined
+      })
+    }));
+  }
+  toCustomer(customer) {
+    const metadata = this.toMetadata(customer.metadata);
+    const updatedAtValue = metadata?.updatedAt;
+    return {
+      id: customer.id,
+      email: customer.email ?? undefined,
+      name: customer.name ?? undefined,
+      metadata,
+      createdAt: customer.created ? new Date(customer.created * 1000) : undefined,
+      updatedAt: updatedAtValue ? new Date(updatedAtValue) : undefined
+    };
+  }
+  toPaymentIntent(intent) {
+    const metadata = this.toMetadata(intent.metadata);
+    return {
+      id: intent.id,
+      amount: this.toMoney(intent.amount_received ?? intent.amount ?? 0, intent.currency),
+      status: mapPaymentIntentStatus(intent.status),
+      customerId: typeof intent.customer === "string" ? intent.customer : intent.customer?.id,
+      description: intent.description ?? undefined,
+      clientSecret: intent.client_secret ?? undefined,
+      metadata,
+      createdAt: new Date(intent.created * 1000),
+      updatedAt: intent.canceled_at != null ? new Date(intent.canceled_at * 1000) : new Date(intent.created * 1000)
+    };
+  }
+  toInvoice(invoice) {
+    const metadata = this.toMetadata(invoice.metadata);
+    return {
+      id: invoice.id,
+      number: invoice.number ?? undefined,
+      status: invoice.status ?? "draft",
+      amountDue: this.toMoney(invoice.amount_due ?? 0, invoice.currency),
+      amountPaid: this.toMoney(invoice.amount_paid ?? 0, invoice.currency),
+      customerId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id,
+      dueDate: invoice.due_date ? new Date(invoice.due_date * 1000) : undefined,
+      hostedInvoiceUrl: invoice.hosted_invoice_url ?? undefined,
+      metadata,
+      createdAt: invoice.created ? new Date(invoice.created * 1000) : undefined,
+      updatedAt: invoice.status_transitions?.finalized_at ? new Date(invoice.status_transitions.finalized_at * 1000) : undefined
+    };
+  }
+  toMoney(amount, currency) {
+    return {
+      amount,
+      currency: currency?.toUpperCase() ?? "USD"
+    };
+  }
+  toMetadata(metadata) {
+    if (!metadata)
+      return;
+    const entries = Object.entries(metadata).filter((entry) => typeof entry[1] === "string");
+    if (entries.length === 0)
+      return;
+    return Object.fromEntries(entries);
+  }
+  mergeMetadata(base, extras) {
+    const filteredExtras = Object.entries(extras).filter((entry) => typeof entry[1] === "string");
+    if (!base && filteredExtras.length === 0) {
+      return;
+    }
+    return {
+      ...base ?? {},
+      ...Object.fromEntries(filteredExtras)
+    };
+  }
+}
+function mapRefundReason(reason) {
+  if (!reason)
+    return;
+  const allowed = [
+    "duplicate",
+    "fraudulent",
+    "requested_by_customer"
+  ];
+  return allowed.includes(reason) ? reason : undefined;
+}
+function mapPaymentIntentStatus(status) {
+  switch (status) {
+    case "requires_payment_method":
+      return "requires_payment_method";
+    case "requires_confirmation":
+      return "requires_confirmation";
+    case "requires_action":
+    case "requires_capture":
+      return "requires_action";
+    case "processing":
+      return "processing";
+    case "succeeded":
+      return "succeeded";
+    case "canceled":
+      return "canceled";
+    default:
+      return "requires_payment_method";
+  }
+}
+function mapRefundStatus(status) {
+  switch (status) {
+    case "pending":
+    case "succeeded":
+    case "failed":
+    case "canceled":
+      return status;
+    default:
+      return "pending";
+  }
+}
+function mapChargeStatus(status) {
+  switch (status) {
+    case "pending":
+    case "processing":
+      return "pending";
+    case "succeeded":
+      return "succeeded";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+export {
+  StripePaymentsProvider
+};

package/dist/node/impls/supabase-psql.js

@@ -0,0 +1,150 @@
+// src/impls/supabase-psql.ts
+import { Buffer } from "node:buffer";
+import { sql as drizzleSql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+class SupabasePostgresProvider {
+  client;
+  db;
+  ownsClient;
+  createDrizzle;
+  constructor(options = {}) {
+    this.createDrizzle = options.createDrizzle ?? ((client) => drizzle(client));
+    if (options.db) {
+      if (!options.client) {
+        throw new Error("SupabasePostgresProvider requires a postgres client when db is provided.");
+      }
+      this.client = options.client;
+      this.db = options.db;
+      this.ownsClient = false;
+      return;
+    }
+    if (options.client) {
+      this.client = options.client;
+      this.ownsClient = false;
+    } else {
+      if (!options.connectionString) {
+        throw new Error("SupabasePostgresProvider requires either a connectionString or a client.");
+      }
+      this.client = postgres(options.connectionString, {
+        max: options.maxConnections,
+        prepare: false,
+        ssl: resolveSslMode(options.sslMode)
+      });
+      this.ownsClient = true;
+    }
+    this.db = this.createDrizzle(this.client);
+  }
+  async query(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    const result = await this.db.execute(query);
+    const rows = asRows(result);
+    return {
+      rows,
+      rowCount: rows.length
+    };
+  }
+  async execute(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    await this.db.execute(query);
+  }
+  async transaction(run) {
+    const transactionResult = this.client.begin(async (transactionClient) => {
+      const transactionalProvider = new SupabasePostgresProvider({
+        client: transactionClient,
+        db: this.createDrizzle(transactionClient),
+        createDrizzle: this.createDrizzle
+      });
+      return run(transactionalProvider);
+    });
+    return transactionResult;
+  }
+  async close() {
+    if (this.ownsClient) {
+      await this.client.end({ timeout: 5 });
+    }
+  }
+}
+function buildParameterizedSql(statement, params) {
+  const segments = [];
+  const pattern = /\$(\d+)/g;
+  let cursor = 0;
+  for (const match of statement.matchAll(pattern)) {
+    const token = match[0];
+    const indexPart = match[1];
+    const start = match.index;
+    if (indexPart == null || start == null)
+      continue;
+    const parameterIndex = Number(indexPart) - 1;
+    if (!Number.isInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= params.length) {
+      throw new Error(`SQL placeholder ${token} is out of bounds for ${params.length} parameter(s).`);
+    }
+    const staticSegment = statement.slice(cursor, start);
+    if (staticSegment.length > 0) {
+      segments.push(drizzleSql.raw(staticSegment));
+    }
+    const parameterValue = params[parameterIndex];
+    if (parameterValue === undefined) {
+      throw new Error(`SQL placeholder ${token} is missing a parameter value.`);
+    }
+    const normalizedValue = normalizeParam(parameterValue);
+    segments.push(drizzleSql`${normalizedValue}`);
+    cursor = start + token.length;
+  }
+  const tailSegment = statement.slice(cursor);
+  if (tailSegment.length > 0) {
+    segments.push(drizzleSql.raw(tailSegment));
+  }
+  if (segments.length === 0) {
+    return drizzleSql.raw("");
+  }
+  return drizzleSql.join(segments);
+}
+function normalizeParam(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+  if (isPlainObject(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function asRows(result) {
+  if (!Array.isArray(result)) {
+    return [];
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (value instanceof Uint8Array) {
+    return false;
+  }
+  return true;
+}
+function resolveSslMode(mode) {
+  switch (mode) {
+    case "allow":
+      return false;
+    case "prefer":
+      return "prefer";
+    case "require":
+    default:
+      return "require";
+  }
+}
+export {
+  SupabasePostgresProvider
+};