samva 0.17.0 → 0.18.0

package/dist/promises/index.js

@@ -1,4 +1,289 @@
-import { t as MediaUploadError } from "../inline-attachments-Bi1hDltp.js";
-import { C as SenderNotReadyError, E as fromApiError, S as SamvaTransportError, T as ValidationError, _ as OnboardingReviewRequiredError, a as CampaignFooterRequiredError, b as ResourceNotFoundError, c as EmailChannelError, d as ForbiddenError, f as GatewayTimeoutError, g as MailboxSendRefusedError, h as MailboxSendConflictError, i as BrandAddressRequiredError, l as ExternalServiceError, m as MailboxChannelUnsupportedError, n as AnalyticsQueryError, o as ConflictError, p as InternalError, r as BillingProviderError, s as DeliveryUnavailableError, t as createClient, u as FlagDisabledError, v as PaymentRequiredError, w as UnauthorizedError, x as SamvaApiError, y as RateLimitedError } from "../promises---Kbh-7z.js";
-import { n as MailboxEventStreamError, t as MailboxEventStream } from "../mailbox-events-VKR4f3qq.js";
+import { CLIENT_ATTRIBUTION_HEADER, clientAttribution } from "../client-attribution.js";
+import { mergeHeaders } from "../client/client/utils.gen.js";
+import { createClient as createClient$1 } from "../client/client/client.gen.js";
+import { Analytics, ApiKeys, Attachments, Brands, Campaigns, ContactEvents, ContactGroups, Contacts, Conversations, CustomFields, Email, Events, ExtensionInstallations, Extensions, Feedback, Journeys, Mailboxes, Media, Messages, Namespaces, Operations, Organizations, ScheduledMessages, Subscriptions, Templates, Unsubscribe, Webhooks, Whoami } from "../client/sdk.gen.js";
+import { MediaUploadError, mediaCreateBody, planInlineUploads, withUploadedAttachments } from "../inline-attachments.js";
+import { MailboxEventStream, MailboxEventStreamError } from "../mailbox-events.js";
+import { buildEmailSendPayload, buildMessagesSendPayload, replyToEmailsPayload } from "../normalize.js";
+import { AnalyticsQueryError, BillingProviderError, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, DeliveryUnavailableError, EmailChannelError, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, MailboxChannelUnsupportedError, MailboxSendConflictError, MailboxSendRefusedError, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SamvaApiError, SamvaTransportError, SenderNotReadyError, UnauthorizedError, ValidationError, fromApiError } from "./errors.gen.js";
+//#region src/promises/index.ts
+/**
+* Samva SDK - TypeScript client for the Samva API.
+*
+* Ergonomic methods resolve with decoded success values and throw generated
+* plain-JavaScript error classes. The bound Hey API result surface remains
+* available under `client.raw` for transport-level access.
+*
+* @example
+* ```typescript
+* import { createClient, RateLimitedError } from "samva";
+*
+* const samva = createClient({ apiKey: "<samva-api-key>" });
+*
+* try {
+*   const { contact } = await samva.contacts.findOrCreate({
+*     create: { name: "Ada Lovelace" },
+*     lookup: { type: "email", value: "ada@example.com" },
+*   });
+*   await samva.email.send({
+*     to: contact,
+*     subject: "Hello",
+*     html: "<p>Hi there!</p>",
+*   });
+* } catch (error) {
+*   if (error instanceof RateLimitedError) console.log(error.retryAfterSeconds);
+* }
+* ```
+*/
+const isObject = (value) => typeof value === "object" && value !== null;
+/**
+* The key a retry-safe call sends as `idempotency-key`: the `idempotencyKey`
+* option, else one the caller set in `headers`, else a fresh UUID. The
+* generated header parameter is applied after request headers, so it must carry
+* a caller-set header value rather than overwrite it.
+*/
+function resolveIdempotencyKey(options) {
+	const { idempotencyKey, ...requestOptions } = options ?? {};
+	return {
+		idempotencyKey: idempotencyKey ?? mergeHeaders(requestOptions.headers).get("idempotency-key") ?? crypto.randomUUID(),
+		requestOptions
+	};
+}
+/**
+* Inline attachment content over the API's request cap travels as media instead: the largest
+* attachments are uploaded (create, put to the presigned URL, complete) and replaced by their
+* `mediaId`. The returned payload is the one request every send attempt reuses, so nothing is
+* uploaded twice.
+*/
+async function uploadOversizedAttachments(clientInstance, payload, requestOptions) {
+	const plan = planInlineUploads(payload);
+	if (plan.length === 0) return payload;
+	const uploaded = /* @__PURE__ */ new Map();
+	const directMedia = createDirectService(createBoundService(Media, clientInstance));
+	for (const upload of plan) {
+		const created = await directMedia.create(mediaCreateBody(upload), requestOptions);
+		await putUpload(clientInstance, upload, created, requestOptions.signal ?? void 0);
+		await directMedia.complete({ id: created.id }, requestOptions);
+		uploaded.set(upload.index, {
+			mediaId: created.id,
+			upload
+		});
+	}
+	return withUploadedAttachments(payload, uploaded);
+}
+/**
+* Send with oversized inline attachments uploaded first. Within the cap this is the send call
+* itself, one request and no extra await, so its result is returned unchanged.
+*/
+function sendWithUploads(clientInstance, payload, requestOptions, send) {
+	if (planInlineUploads(payload).length === 0) return send(payload);
+	return uploadOversizedAttachments(clientInstance, payload, requestOptions).then(send);
+}
+async function putUpload(clientInstance, upload, created, signal) {
+	const fail = (status, cause) => new MediaUploadError({
+		filename: upload.filename,
+		mediaId: created.id,
+		status,
+		cause
+	});
+	let response;
+	try {
+		response = await (clientInstance.getConfig().fetch ?? globalThis.fetch)(new Request(created.upload.url, {
+			method: created.upload.method,
+			headers: created.upload.headers,
+			body: upload.bytes,
+			signal: signal ?? null
+		}));
+	} catch (error) {
+		throw fail(void 0, error);
+	}
+	if (!response.ok) throw fail(response.status);
+}
+function createPromiseMessagesTransport(clientInstance) {
+	const boundMessages = createBoundService(Messages, clientInstance);
+	return {
+		list: boundMessages.list,
+		remove: boundMessages.remove,
+		get: boundMessages.get,
+		getEmail: boundMessages.getEmail,
+		getStatus: boundMessages.getStatus,
+		getEvents: boundMessages.getEvents,
+		listDeliveries: boundMessages.listDeliveries,
+		getContent: boundMessages.getContent,
+		validateEmail: boundMessages.validateEmail,
+		send: (input, options) => {
+			const { idempotencyKey, requestOptions } = resolveIdempotencyKey(options);
+			return sendWithUploads(clientInstance, buildMessagesSendPayload(input), requestOptions, (payload) => Messages.send({
+				"idempotency-key": idempotencyKey,
+				...payload
+			}, {
+				...requestOptions,
+				client: clientInstance
+			}));
+		}
+	};
+}
+function createPromiseEmailTransport(clientInstance) {
+	const boundEmail = createBoundService(Email, clientInstance);
+	return Object.assign(boundEmail, {
+		addSender: (input, options) => {
+			const { replyToEmails, ...sender } = input;
+			const { idempotencyKey, requestOptions } = resolveIdempotencyKey(options);
+			return Email.addSender({
+				"idempotency-key": idempotencyKey,
+				...sender,
+				...replyToEmailsPayload(replyToEmails)
+			}, {
+				...requestOptions,
+				client: clientInstance
+			});
+		},
+		send: (input, options) => {
+			const { idempotencyKey, requestOptions } = resolveIdempotencyKey(options);
+			return sendWithUploads(clientInstance, buildEmailSendPayload(input), requestOptions, (payload) => Messages.send({
+				"idempotency-key": idempotencyKey,
+				...payload
+			}, {
+				...requestOptions,
+				client: clientInstance
+			}));
+		}
+	});
+}
+function createPromiseTemplatesTransport(clientInstance) {
+	return createBoundService(Templates, clientInstance);
+}
+function createBoundService(service, clientInstance) {
+	const bound = {};
+	for (const key of Object.getOwnPropertyNames(service)) {
+		if (key === "length" || key === "name" || key === "prototype") continue;
+		const value = service[key];
+		if (typeof value === "function") bound[key] = value.length >= 2 ? (parameters, options) => value(parameters ?? {}, {
+			...options,
+			client: clientInstance
+		}) : (options) => value({
+			...options,
+			client: clientInstance
+		});
+		else if (isObject(value)) bound[key] = createBoundService(value, clientInstance);
+		else bound[key] = value;
+	}
+	return bound;
+}
+const directOptions = (options) => ({
+	...isObject(options) ? options : {},
+	responseStyle: "fields",
+	throwOnError: false
+});
+async function unwrap(method, arguments_) {
+	let result;
+	try {
+		result = await method(...arguments_);
+	} catch (error) {
+		if (error instanceof MediaUploadError) throw error;
+		throw fromApiError(error);
+	}
+	if (!isObject(result)) throw new SamvaTransportError(result);
+	const raw = result;
+	const context = {
+		request: raw.request,
+		response: raw.response
+	};
+	if (raw.error !== void 0) throw fromApiError(raw.error, context);
+	if ("data" in raw) return raw.data;
+	throw new SamvaTransportError(result, context);
+}
+function createDirectService(service) {
+	const direct = {};
+	for (const [key, value] of Object.entries(service)) if (typeof value === "function") direct[key] = value.length >= 2 ? (parameters = {}, options = {}) => unwrap(value, [parameters, directOptions(options)]) : (options = {}) => unwrap(value, [directOptions(options)]);
+	else if (isObject(value)) direct[key] = createDirectService(value);
+	else direct[key] = value;
+	return direct;
+}
+/** Create a configured Promise client. */
+function createClient(config) {
+	const authHeaders = config.authToken !== void 0 ? { Authorization: `Bearer ${config.authToken}` } : { "X-API-Key": config.apiKey };
+	const clientInstance = createClient$1({
+		...config,
+		baseUrl: config.baseUrl ?? "https://api.samva.dev",
+		headers: mergeHeaders({ [CLIENT_ATTRIBUTION_HEADER]: clientAttribution("typescript-promise") }, config.headers, authHeaders),
+		responseStyle: "fields",
+		throwOnError: false
+	});
+	clientInstance.interceptors.request.use((request) => {
+		const headers = new Headers(request.headers);
+		for (const [name, value] of Object.entries(authHeaders)) headers.set(name, value);
+		return new Request(request, { headers });
+	});
+	const raw = {
+		client: clientInstance,
+		messages: createBoundService(Messages, clientInstance),
+		scheduledMessages: createBoundService(ScheduledMessages, clientInstance),
+		brands: createBoundService(Brands, clientInstance),
+		campaigns: createBoundService(Campaigns, clientInstance),
+		email: createBoundService(Email, clientInstance),
+		media: createBoundService(Media, clientInstance),
+		templates: createPromiseTemplatesTransport(clientInstance),
+		contacts: Object.assign(createBoundService(Contacts, clientInstance), createBoundService(ContactEvents, clientInstance)),
+		events: createBoundService(Events, clientInstance),
+		conversations: createBoundService(Conversations, clientInstance),
+		webhooks: createBoundService(Webhooks, clientInstance),
+		operations: createBoundService(Operations, clientInstance),
+		apiKeys: createBoundService(ApiKeys, clientInstance),
+		organizations: createBoundService(Organizations, clientInstance),
+		attachments: createBoundService(Attachments, clientInstance),
+		contactGroups: createBoundService(ContactGroups, clientInstance),
+		customFields: createBoundService(CustomFields, clientInstance),
+		subscriptions: createBoundService(Subscriptions, clientInstance),
+		unsubscribeGroups: createBoundService(Unsubscribe, clientInstance),
+		analytics: createBoundService(Analytics, clientInstance),
+		feedback: createBoundService(Feedback, clientInstance),
+		whoami: createBoundService(Whoami, clientInstance),
+		journeys: createBoundService(Journeys, clientInstance),
+		mailboxes: createBoundService(Mailboxes, clientInstance),
+		namespaces: createBoundService(Namespaces, clientInstance),
+		extensions: createBoundService(Extensions, clientInstance),
+		extensionInstallations: createBoundService(ExtensionInstallations, clientInstance)
+	};
+	const streamConnection = {
+		baseUrl: config.baseUrl ?? "https://api.samva.dev",
+		headers: async () => Object.fromEntries(mergeHeaders({ [CLIENT_ATTRIBUTION_HEADER]: clientAttribution("typescript-promise") }, config.headers, authHeaders).entries()),
+		fetch: config.fetch
+	};
+	const promiseMessages = createPromiseMessagesTransport(clientInstance);
+	const promiseEmail = createPromiseEmailTransport(clientInstance);
+	return {
+		raw,
+		messages: createDirectService(promiseMessages),
+		scheduledMessages: createDirectService(raw.scheduledMessages),
+		brands: createDirectService(raw.brands),
+		campaigns: createDirectService(raw.campaigns),
+		email: createDirectService(promiseEmail),
+		media: createDirectService(raw.media),
+		templates: createDirectService(raw.templates),
+		contacts: createDirectService(raw.contacts),
+		events: createDirectService(raw.events),
+		conversations: createDirectService(raw.conversations),
+		webhooks: createDirectService(raw.webhooks),
+		operations: createDirectService(raw.operations),
+		apiKeys: createDirectService(raw.apiKeys),
+		organizations: createDirectService(raw.organizations),
+		attachments: createDirectService(raw.attachments),
+		contactGroups: createDirectService(raw.contactGroups),
+		customFields: createDirectService(raw.customFields),
+		subscriptions: createDirectService(raw.subscriptions),
+		unsubscribeGroups: createDirectService(raw.unsubscribeGroups),
+		analytics: createDirectService(raw.analytics),
+		feedback: createDirectService(raw.feedback),
+		whoami: createDirectService(raw.whoami),
+		journeys: createDirectService(raw.journeys),
+		mailboxes: Object.assign(createDirectService(raw.mailboxes), { events: (options) => new MailboxEventStream(streamConnection, options) }),
+		namespaces: createDirectService(raw.namespaces),
+		extensions: createDirectService(raw.extensions),
+		extensionInstallations: createDirectService(raw.extensionInstallations)
+	};
+}
+//#endregion
 export { AnalyticsQueryError, BillingProviderError, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, DeliveryUnavailableError, EmailChannelError, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, MailboxChannelUnsupportedError, MailboxEventStream, MailboxEventStreamError, MailboxSendConflictError, MailboxSendRefusedError, MediaUploadError, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SamvaApiError, SamvaTransportError, SenderNotReadyError, UnauthorizedError, ValidationError, createClient, fromApiError };
+
+//# sourceMappingURL=index.js.map

package/dist/{operation-n_IYgNVK.js → service-map.js}

@@ -1,7 +1,3 @@
-import { t as Service } from "./client-DOzUrdTE.js";
-import { y as SamvaOperations } from "./categories-CA4XIQAb.js";
-import { withRetry } from "./effect/retry.js";
-import { Effect, Option, Predicate, Stream } from "effect";
 //#region src/service-map.ts
 /** How each generated Effect operation is adapted to the Promise facade's direct input shape. */
 const SDK_OPERATION_CALLS = {
@@ -1050,148 +1046,6 @@ const SDK_OPERATION_CALLS = {
 	}
 };
 //#endregion
-//#region src/effect/pagination.ts
-/**
-* Stream pagination for the Effect SDK.
-*
-* Every list operation whose success value is a page envelope gains `.pages()`
-* and `.items()` companions on its domain operation. `.pages()` streams the raw
-* envelopes; `.items()` flattens them into a stream of items. Every list pages
-* by cursor, `{ items, nextCursor }`: each step passes the previous page's
-* `nextCursor` as `cursor`, and the walk stops at a null `nextCursor`.
-*
-* The traversal is **lazy**: built on `Stream.paginate` (a pull-based source),
-* so each page is fetched only as the stream is consumed — `Stream.take(n)`
-* stops requesting further pages. Caller params (the start `cursor`,
-* `limit`, filters) are respected; only the position is advanced per step.
-*
-* Retry is **not** re-applied here: the underlying domain operation is already
-* wrapped in the ambient {@link import("./retry").Service} policy (reads are
-* retry-safe), so each page fetch retries on its own and pagination composes
-* with retry instead of nesting retries.
-*/
-/** Honor a caller-supplied start `cursor`; default to the first page otherwise. */
-const startCursorOf = (input) => {
-	const cursor = input?.cursor;
-	return typeof cursor === "string" ? cursor : void 0;
-};
-/** Fetch the page at `cursor`, preserving all other caller params. */
-const fetchCursorPage = (operation, input, cursor) => operation({
-	...input,
-	cursor
-});
-/** Stream the raw cursor page envelopes, one per request, from the caller's start cursor. */
-const streamCursorPages = (operation, input) => Stream.paginate(startCursorOf(input), (cursor) => fetchCursorPage(operation, input, cursor).pipe(Effect.map((result) => [[result], Option.fromNullishOr(result.nextCursor)])));
-/** Stream individual items across cursor pages, fetching the next page only when pulled. */
-const streamCursorItems = (operation, input) => Stream.paginate(startCursorOf(input), (cursor) => fetchCursorPage(operation, input, cursor).pipe(Effect.map((result) => [result.items, Option.fromNullishOr(result.nextCursor)])));
-//#endregion
-//#region src/effect/internal/operation.ts
-const READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
-const MODULE_NAMES = {
-	analytics: "Analytics",
-	apiKeys: "ApiKeys",
-	attachments: "Attachments",
-	brands: "Brands",
-	campaigns: "Campaigns",
-	contactGroups: "ContactGroups",
-	contacts: "Contacts",
-	conversations: "Conversations",
-	customFields: "CustomFields",
-	email: "Email",
-	extensions: "Extensions",
-	feedback: "Feedback",
-	mailboxes: "Mailboxes",
-	media: "Media",
-	messages: "Messages",
-	namespaces: "Namespaces",
-	operations: "Operations",
-	organizations: "Organizations",
-	scheduledMessages: "ScheduledMessages",
-	templates: "Templates",
-	unsubscribe: "UnsubscribeGroups",
-	webhooks: "Webhooks",
-	whoami: "Whoami"
-};
-const traceName = (operationName) => {
-	for (const [prefix, moduleName] of Object.entries(MODULE_NAMES)) {
-		if (!operationName.startsWith(prefix)) continue;
-		const method = operationName.slice(prefix.length);
-		return `${moduleName}.${method[0].toLowerCase()}${method.slice(1)}`;
-	}
-	return `Samva.${operationName}`;
-};
-const stripUndefined = (input) => {
-	if (!Predicate.isObject(input)) return input;
-	if (Array.isArray(input)) return input.map(stripUndefined);
-	if (Object.getPrototypeOf(input) !== Object.prototype) return input;
-	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0).map(([key, value]) => [key, stripUndefined(value)]));
-};
-const adapt = (operationName, rawCall, input) => {
-	const descriptor = SDK_OPERATION_CALLS[operationName];
-	const call = READ_METHODS.has(SamvaOperations[operationName].method) ? (request) => withRetry(rawCall(request)) : rawCall;
-	if (descriptor.kind === "none") return call();
-	if (descriptor.kind === "params") return call({ query: stripUndefined(input) });
-	if (descriptor.kind === "payload") return call({ payload: stripUndefined(input) });
-	if (descriptor.kind === "idempotentPayload") {
-		const { idempotencyKey, ...payload } = input;
-		return call({
-			headers: { "idempotency-key": idempotencyKey },
-			payload: stripUndefined(payload)
-		});
-	}
-	const pathDescriptor = descriptor;
-	const inputRecord = input ?? {};
-	const params = {};
-	for (const path of pathDescriptor.paths) {
-		if (inputRecord[path] === void 0) return Effect.die(/* @__PURE__ */ new Error(`${operationName} requires path field ${path}`));
-		params[path] = inputRecord[path];
-	}
-	if (pathDescriptor.kind === "path") return call({ params });
-	if (pathDescriptor.kind === "idempotentPath") return call({
-		params,
-		headers: { "idempotency-key": inputRecord.idempotencyKey }
-	});
-	const optionalKeyHeaders = { headers: inputRecord.idempotencyKey === void 0 ? {} : { "idempotency-key": inputRecord.idempotencyKey } };
-	if (pathDescriptor.kind === "optionalIdempotentPath") return call({
-		params,
-		...optionalKeyHeaders
-	});
-	const headerKey = pathDescriptor.kind === "optionalIdempotentPathPayload";
-	const remainingInput = stripUndefined(Object.fromEntries(Object.entries(inputRecord).filter(([key]) => !pathDescriptor.paths.includes(key) && !(headerKey && key === "idempotencyKey"))));
-	if (pathDescriptor.kind === "optionalIdempotentPathPayload") return call({
-		params,
-		payload: remainingInput,
-		...optionalKeyHeaders
-	});
-	return call({
-		params,
-		[pathDescriptor.kind === "pathParams" ? "query" : "payload"]: remainingInput
-	});
-};
-const isCursorPageEnvelope = (value) => Predicate.isObject(value) && Array.isArray(value.items) && (value.nextCursor === null || typeof value.nextCursor === "string");
-/**
-* Operation factory for one API group. Each domain module binds its own group, so importing it
-* loads that group's schemas and nothing else.
-*/
-const forGroup = (group) => (operationName) => {
-	if (SamvaOperations[operationName].group !== group.identifier) throw new Error(`${operationName} is not an endpoint of ${group.identifier}`);
-	return make(group, operationName);
-};
-/** Call one endpoint with an already-shaped request, outside the direct-operation adapter. */
-const callEndpoint = (group, name, request) => Effect.flatMap(Service, (client) => Effect.flatMap(client.endpoint(group, name), (call) => call(request)));
-const make = (group, operationName) => {
-	const call = Effect.fn(traceName(operationName))((input) => Effect.flatMap(Service, (client) => Effect.flatMap(client.endpoint(group, operationName), (rawCall) => adapt(operationName, rawCall, input))));
-	const operation = call;
-	if (SamvaOperations[operationName].paginated) {
-		const list = (input) => Effect.filterOrElse(call(input), isCursorPageEnvelope, () => Effect.die(/* @__PURE__ */ new Error(`${operationName} did not return a cursor page envelope`)));
-		Object.assign(operation, {
-			pages: (input) => streamCursorPages(list, input ?? {}),
-			items: (input) => streamCursorItems(list, input ?? {})
-		});
-	}
-	return operation;
-};
-//#endregion
-export { forGroup as n, stripUndefined as r, callEndpoint as t };
+export { SDK_OPERATION_CALLS };
 
-//# sourceMappingURL=operation-n_IYgNVK.js.map
+//# sourceMappingURL=service-map.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "samva",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "TypeScript SDK for the Samva email API",
   "keywords": [
     "api-client",
@@ -47,6 +47,10 @@
       "types": "./dist/effect/index.d.ts",
       "import": "./dist/effect/index.js"
     },
+    "./effect/errors": {
+      "types": "./dist/effect/errors.d.ts",
+      "import": "./dist/effect/errors.js"
+    },
     "./effect/categories": {
       "types": "./dist/effect/categories.d.ts",
       "import": "./dist/effect/categories.js"
@@ -196,7 +200,7 @@
     "typecheck": "tsc --noEmit && tsc --noEmit -p codegen/tsconfig.json && tsc --noEmit -p tests/tsconfig.json"
   },
   "dependencies": {
-    "@samva/webhooks": "0.17.0"
+    "@samva/webhooks": "0.18.0"
   },
   "devDependencies": {
     "@effect/openapi-generator": "4.0.0",