@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/integrations/providers/impls/provider-factory.js

@@ -1,146 +0,0 @@
-import { ElevenLabsVoiceProvider } from "./elevenlabs-voice.js";
-import { GoogleCloudStorageProvider } from "./gcs-storage.js";
-import { MistralLLMProvider } from "./mistral-llm.js";
-import { MistralEmbeddingProvider } from "./mistral-embedding.js";
-import { QdrantVectorProvider } from "./qdrant-vector.js";
-import { StripePaymentsProvider } from "./stripe-payments.js";
-import { PostmarkEmailProvider } from "./postmark-email.js";
-import { TwilioSmsProvider } from "./twilio-sms.js";
-import { PowensOpenBankingProvider } from "./powens-openbanking.js";
-import { Buffer } from "node:buffer";
-
-//#region src/integrations/providers/impls/provider-factory.ts
-const SECRET_CACHE = /* @__PURE__ */ new Map();
-var IntegrationProviderFactory = class {
-	async createPaymentsProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "payments.stripe": return new StripePaymentsProvider({ apiKey: requireSecret(secrets, "apiKey", "Stripe API key is required") });
-			default: throw new Error(`Unsupported payments integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createEmailOutboundProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "email.postmark": return new PostmarkEmailProvider({
-				serverToken: requireSecret(secrets, "serverToken", "Postmark server token is required"),
-				defaultFromEmail: context.config.fromEmail,
-				messageStream: context.config.messageStream
-			});
-			default: throw new Error(`Unsupported email integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createSmsProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "sms.twilio": return new TwilioSmsProvider({
-				accountSid: requireSecret(secrets, "accountSid", "Twilio account SID is required"),
-				authToken: requireSecret(secrets, "authToken", "Twilio auth token is required"),
-				fromNumber: context.config.fromNumber
-			});
-			default: throw new Error(`Unsupported SMS integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createVectorStoreProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "vectordb.qdrant": return new QdrantVectorProvider({
-				url: requireConfig(context, "apiUrl", "Qdrant apiUrl config is required"),
-				apiKey: secrets.apiKey,
-				clientParams: context.config
-			});
-			default: throw new Error(`Unsupported vector store integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createObjectStorageProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "storage.s3":
-			case "storage.gcs": return new GoogleCloudStorageProvider({
-				bucket: requireConfig(context, "bucket", "Storage bucket is required"),
-				clientOptions: secrets.type === "service_account" ? { credentials: secrets } : void 0
-			});
-			default: throw new Error(`Unsupported storage integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createVoiceProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "ai-voice.elevenlabs": return new ElevenLabsVoiceProvider({
-				apiKey: requireSecret(secrets, "apiKey", "ElevenLabs API key is required"),
-				defaultVoiceId: context.config.defaultVoiceId
-			});
-			default: throw new Error(`Unsupported voice integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createLlmProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "ai-llm.mistral": return new MistralLLMProvider({
-				apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
-				defaultModel: context.config.model
-			});
-			default: throw new Error(`Unsupported LLM integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createEmbeddingProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		switch (context.spec.meta.key) {
-			case "ai-llm.mistral": return new MistralEmbeddingProvider({
-				apiKey: requireSecret(secrets, "apiKey", "Mistral API key is required"),
-				defaultModel: context.config.embeddingModel
-			});
-			default: throw new Error(`Unsupported embeddings integration: ${context.spec.meta.key}`);
-		}
-	}
-	async createOpenBankingProvider(context) {
-		const secrets = await this.loadSecrets(context);
-		const config = context.config;
-		switch (context.spec.meta.key) {
-			case "openbanking.powens": {
-				const environmentValue = requireConfig(context, "environment", "Powens environment (sandbox | production) must be specified in integration config.");
-				if (environmentValue !== "sandbox" && environmentValue !== "production") throw new Error(`Powens environment "${environmentValue}" is invalid. Expected "sandbox" or "production".`);
-				return new PowensOpenBankingProvider({
-					clientId: requireSecret(secrets, "clientId", "Powens clientId is required"),
-					clientSecret: requireSecret(secrets, "clientSecret", "Powens clientSecret is required"),
-					apiKey: secrets.apiKey,
-					environment: environmentValue,
-					baseUrl: config?.baseUrl
-				});
-			}
-			default: throw new Error(`Unsupported open banking integration: ${context.spec.meta.key}`);
-		}
-	}
-	async loadSecrets(context) {
-		const cacheKey = context.connection.meta.id;
-		if (SECRET_CACHE.has(cacheKey)) {
-			const cached = SECRET_CACHE.get(cacheKey);
-			if (cached) return cached;
-		}
-		const value = parseSecret(await context.secretProvider.getSecret(context.secretReference));
-		SECRET_CACHE.set(cacheKey, value);
-		return value;
-	}
-};
-function parseSecret(secret) {
-	const text = Buffer.from(secret.data).toString("utf-8").trim();
-	if (!text) return {};
-	try {
-		return JSON.parse(text);
-	} catch {
-		return { apiKey: text };
-	}
-}
-function requireSecret(secrets, key, message) {
-	const value = secrets[key];
-	if (value == null || value === "") throw new Error(message);
-	return value;
-}
-function requireConfig(context, key, message) {
-	const value = context.config?.[key];
-	if (value == null) throw new Error(message);
-	return value;
-}
-
-//#endregion
-export { IntegrationProviderFactory };

package/dist/integrations/providers/impls/qdrant-vector.d.ts

@@ -1,24 +0,0 @@
-import { VectorDeleteRequest, VectorSearchQuery, VectorSearchResult, VectorStoreProvider, VectorUpsertRequest } from "../vector-store.js";
-import { QdrantClient, QdrantClientParams } from "@qdrant/js-client-rest";
-
-//#region src/integrations/providers/impls/qdrant-vector.d.ts
-interface QdrantVectorProviderOptions {
-  url: string;
-  apiKey?: string;
-  client?: QdrantClient;
-  createCollectionIfMissing?: boolean;
-  distance?: 'Cosine' | 'Euclid' | 'Dot' | 'Manhattan';
-  clientParams?: Omit<QdrantClientParams, 'url' | 'apiKey'>;
-}
-declare class QdrantVectorProvider implements VectorStoreProvider {
-  private readonly client;
-  private readonly createCollectionIfMissing;
-  private readonly distance;
-  constructor(options: QdrantVectorProviderOptions);
-  upsert(request: VectorUpsertRequest): Promise<void>;
-  search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
-  delete(request: VectorDeleteRequest): Promise<void>;
-  private ensureCollection;
-}
-//#endregion
-export { QdrantVectorProvider, QdrantVectorProviderOptions };

package/dist/integrations/providers/impls/qdrant-vector.js

@@ -1,69 +0,0 @@
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-//#region src/integrations/providers/impls/qdrant-vector.ts
-var QdrantVectorProvider = class {
-	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 vectorSize = request.documents[0]?.vector.length ?? 0;
-		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) {
-		return (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
-		})).map((item) => ({
-			id: String(item.id),
-			score: item.score,
-			payload: item.payload ?? void 0,
-			namespace: typeof item.payload === "object" && item.payload !== null ? item.payload.namespace : void 0
-		}));
-	}
-	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 {
-			await this.client.createCollection(collectionName, { vectors: {
-				size: vectorSize,
-				distance: this.distance
-			} });
-		}
-	}
-};
-
-//#endregion
-export { QdrantVectorProvider };

package/dist/integrations/providers/impls/stripe-payments.d.ts

@@ -1,28 +0,0 @@
-import { CapturePaymentInput, CreateCustomerInput, CreatePaymentIntentInput, ListInvoicesQuery, ListTransactionsQuery, PaymentCustomer, PaymentIntent, PaymentInvoice, PaymentRefund, PaymentTransaction, PaymentsProvider, RefundPaymentInput } from "../payments.js";
-import Stripe from "stripe";
-
-//#region src/integrations/providers/impls/stripe-payments.d.ts
-interface StripePaymentsProviderOptions {
-  apiKey: string;
-  stripe?: Stripe;
-}
-declare class StripePaymentsProvider implements PaymentsProvider {
-  private readonly stripe;
-  constructor(options: StripePaymentsProviderOptions);
-  createCustomer(input: CreateCustomerInput): Promise<PaymentCustomer>;
-  getCustomer(customerId: string): Promise<PaymentCustomer | null>;
-  createPaymentIntent(input: CreatePaymentIntentInput): Promise<PaymentIntent>;
-  capturePayment(paymentIntentId: string, input?: CapturePaymentInput): Promise<PaymentIntent>;
-  cancelPaymentIntent(paymentIntentId: string): Promise<PaymentIntent>;
-  refundPayment(input: RefundPaymentInput): Promise<PaymentRefund>;
-  listInvoices(query?: ListInvoicesQuery): Promise<PaymentInvoice[]>;
-  listTransactions(query?: ListTransactionsQuery): Promise<PaymentTransaction[]>;
-  private toCustomer;
-  private toPaymentIntent;
-  private toInvoice;
-  private toMoney;
-  private toMetadata;
-  private mergeMetadata;
-}
-//#endregion
-export { StripePaymentsProvider, StripePaymentsProviderOptions };

package/dist/integrations/providers/impls/stripe-payments.js

@@ -1,202 +0,0 @@
-import Stripe from "stripe";
-
-//#region src/integrations/providers/impls/stripe-payments.ts
-const API_VERSION = "2026-01-28.clover";
-var StripePaymentsProvider = class {
-	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 } : void 0);
-		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 ?? void 0,
-			metadata: this.toMetadata(refund.metadata),
-			createdAt: refund.created ? /* @__PURE__ */ new Date(refund.created * 1e3) : void 0
-		};
-	}
-	async listInvoices(query) {
-		const requestedStatus = query?.status?.[0];
-		const stripeStatus = requestedStatus && requestedStatus !== "deleted" ? requestedStatus : void 0;
-		return (await this.stripe.invoices.list({
-			customer: query?.customerId,
-			status: stripeStatus,
-			limit: query?.limit,
-			starting_after: query?.startingAfter
-		})).data.map((invoice) => this.toInvoice(invoice));
-	}
-	async listTransactions(query) {
-		return (await this.stripe.charges.list({
-			customer: query?.customerId,
-			payment_intent: query?.paymentIntentId,
-			limit: query?.limit,
-			starting_after: query?.startingAfter
-		})).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 ?? void 0,
-			createdAt: /* @__PURE__ */ new Date(charge.created * 1e3),
-			metadata: this.mergeMetadata(this.toMetadata(charge.metadata), { balanceTransaction: typeof charge.balance_transaction === "string" ? charge.balance_transaction : void 0 })
-		}));
-	}
-	toCustomer(customer) {
-		const metadata = this.toMetadata(customer.metadata);
-		const updatedAtValue = metadata?.updatedAt;
-		return {
-			id: customer.id,
-			email: customer.email ?? void 0,
-			name: customer.name ?? void 0,
-			metadata,
-			createdAt: customer.created ? /* @__PURE__ */ new Date(customer.created * 1e3) : void 0,
-			updatedAt: updatedAtValue ? new Date(updatedAtValue) : void 0
-		};
-	}
-	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 ?? void 0,
-			clientSecret: intent.client_secret ?? void 0,
-			metadata,
-			createdAt: /* @__PURE__ */ new Date(intent.created * 1e3),
-			updatedAt: intent.canceled_at != null ? /* @__PURE__ */ new Date(intent.canceled_at * 1e3) : /* @__PURE__ */ new Date(intent.created * 1e3)
-		};
-	}
-	toInvoice(invoice) {
-		const metadata = this.toMetadata(invoice.metadata);
-		return {
-			id: invoice.id,
-			number: invoice.number ?? void 0,
-			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 ? /* @__PURE__ */ new Date(invoice.due_date * 1e3) : void 0,
-			hostedInvoiceUrl: invoice.hosted_invoice_url ?? void 0,
-			metadata,
-			createdAt: invoice.created ? /* @__PURE__ */ new Date(invoice.created * 1e3) : void 0,
-			updatedAt: invoice.status_transitions?.finalized_at ? /* @__PURE__ */ new Date(invoice.status_transitions.finalized_at * 1e3) : void 0
-		};
-	}
-	toMoney(amount, currency) {
-		return {
-			amount,
-			currency: currency?.toUpperCase() ?? "USD"
-		};
-	}
-	toMetadata(metadata) {
-		if (!metadata) return void 0;
-		const entries = Object.entries(metadata).filter((entry) => typeof entry[1] === "string");
-		if (entries.length === 0) return void 0;
-		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 void 0;
-	return [
-		"duplicate",
-		"fraudulent",
-		"requested_by_customer"
-	].includes(reason) ? reason : void 0;
-}
-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";
-	}
-}
-
-//#endregion
-export { StripePaymentsProvider };

package/dist/integrations/providers/impls/twilio-sms.d.ts

@@ -1,20 +0,0 @@
-import { SendSmsInput, SmsDeliveryStatus, SmsMessage, SmsProvider } from "../sms.js";
-import Twilio from "twilio";
-
-//#region src/integrations/providers/impls/twilio-sms.d.ts
-type TwilioClient = ReturnType<typeof Twilio>;
-interface TwilioSmsProviderOptions {
-  accountSid: string;
-  authToken: string;
-  fromNumber?: string;
-  client?: TwilioClient;
-}
-declare class TwilioSmsProvider implements SmsProvider {
-  private readonly client;
-  private readonly fromNumber?;
-  constructor(options: TwilioSmsProviderOptions);
-  sendSms(input: SendSmsInput): Promise<SmsMessage>;
-  getDeliveryStatus(messageId: string): Promise<SmsDeliveryStatus>;
-}
-//#endregion
-export { TwilioSmsProvider, TwilioSmsProviderOptions };

package/dist/integrations/providers/impls/twilio-sms.js

@@ -1,58 +0,0 @@
-import Twilio from "twilio";
-
-//#region src/integrations/providers/impls/twilio-sms.ts
-var TwilioSmsProvider = class {
-	client;
-	fromNumber;
-	constructor(options) {
-		this.client = options.client ?? Twilio(options.accountSid, options.authToken);
-		this.fromNumber = options.fromNumber;
-	}
-	async sendSms(input) {
-		const message = await this.client.messages.create({
-			to: input.to,
-			from: input.from ?? this.fromNumber,
-			body: input.body
-		});
-		return {
-			id: message.sid,
-			to: message.to ?? input.to,
-			from: message.from ?? input.from ?? this.fromNumber ?? "",
-			body: message.body ?? input.body,
-			status: mapStatus(message.status),
-			sentAt: message.dateCreated ? new Date(message.dateCreated) : void 0,
-			deliveredAt: message.status === "delivered" && message.dateUpdated ? new Date(message.dateUpdated) : void 0,
-			price: message.price ? Number(message.price) : void 0,
-			priceCurrency: message.priceUnit ?? void 0,
-			errorCode: message.errorCode ? String(message.errorCode) : void 0,
-			errorMessage: message.errorMessage ?? void 0
-		};
-	}
-	async getDeliveryStatus(messageId) {
-		const message = await this.client.messages(messageId).fetch();
-		return {
-			status: mapStatus(message.status),
-			errorCode: message.errorCode ? String(message.errorCode) : void 0,
-			errorMessage: message.errorMessage ?? void 0,
-			updatedAt: message.dateUpdated ? new Date(message.dateUpdated) : /* @__PURE__ */ new Date()
-		};
-	}
-};
-function mapStatus(status) {
-	switch (status) {
-		case "queued":
-		case "accepted":
-		case "scheduled": return "queued";
-		case "sending":
-		case "processing": return "sending";
-		case "sent": return "sent";
-		case "delivered": return "delivered";
-		case "undelivered": return "undelivered";
-		case "failed":
-		case "canceled": return "failed";
-		default: return "queued";
-	}
-}
-
-//#endregion
-export { TwilioSmsProvider };