better-supabase 0.5.0 → 0.6.0

package/dist/blocks/inbox/index.js

@@ -0,0 +1,499 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { D as stringsOf, O as textOf, S as requiredInstant, b as recordOrEmpty, d as isRecord, g as pageOf, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, p as oneOf, u as instantArg, w as seconds, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+//#region src/blocks/inbox/rows.ts
+const INBOX_CHANNELS = [
+	"in_app",
+	"email",
+	"slack",
+	"teams",
+	"discord",
+	"telegram",
+	"whatsapp",
+	"messenger",
+	"instagram",
+	"sms",
+	"github",
+	"linear",
+	"other"
+];
+const channelOf = (value) => oneOf(value, INBOX_CHANNELS, "other");
+const botModeOf = (value) => oneOf(value, [
+	"bot",
+	"human",
+	"paused"
+], "human");
+const nullableText = (value) => optionalText(value) ?? null;
+const nullableInstant = (value) => optionalInstant(value) ?? null;
+function inboxOf(value) {
+	const row = recordOf(value, "inbox");
+	return {
+		id: textOf(row["id"]),
+		tenant: textOf(row["tenant_id"]),
+		name: textOf(row["name"]),
+		channel: channelOf(row["channel"]),
+		address: nullableText(row["channel_address"]),
+		installationId: nullableText(row["installation_id"]),
+		botMode: botModeOf(row["bot_mode"]),
+		settings: recordOrEmpty(row["settings"]),
+		createdAt: requiredInstant(row["created_at"], "inbox.created_at"),
+		archivedAt: nullableInstant(row["archived_at"])
+	};
+}
+function contactOf(value) {
+	const row = recordOf(value, "contact");
+	return {
+		id: textOf(row["id"]),
+		...row["tenant_id"] === void 0 ? {} : { tenant: textOf(row["tenant_id"]) },
+		userId: nullableText(row["user_id"]),
+		name: nullableText(row["name"]),
+		email: nullableText(row["email"]),
+		phone: nullableText(row["phone"]),
+		avatarUrl: nullableText(row["avatar_url"]),
+		...row["metadata"] === void 0 ? {} : { metadata: recordOrEmpty(row["metadata"]) }
+	};
+}
+function conversationOf(value) {
+	const row = recordOf(value, "conversation");
+	const inbox = isRecord(row["inbox"]) ? row["inbox"] : void 0;
+	return {
+		id: textOf(row["id"]),
+		tenant: textOf(row["tenant_id"]),
+		inboxId: textOf(row["inbox_id"]),
+		contactId: textOf(row["contact_id"]),
+		subject: nullableText(row["subject"]),
+		status: oneOf(row["status"], [
+			"open",
+			"pending",
+			"snoozed",
+			"resolved"
+		], "open"),
+		priority: oneOf(row["priority"], [
+			"low",
+			"normal",
+			"high",
+			"urgent"
+		], "normal"),
+		assigneeId: nullableText(row["assignee_id"]),
+		teamId: nullableText(row["team_id"]),
+		botMode: botModeOf(row["bot_mode"]),
+		threadId: textOf(row["thread_id"]),
+		snoozedUntil: nullableInstant(row["snoozed_until"]),
+		lastMessageAt: nullableInstant(row["last_message_at"]),
+		preview: nullableText(row["last_message_preview"]),
+		firstResponseAt: nullableInstant(row["first_response_at"]),
+		resolvedAt: nullableInstant(row["resolved_at"]),
+		metadata: recordOrEmpty(row["metadata"]),
+		createdAt: requiredInstant(row["created_at"], "conversation.created_at"),
+		contact: isRecord(row["contact"]) ? contactOf(row["contact"]) : null,
+		inbox: inbox ? {
+			id: textOf(inbox["id"]),
+			name: textOf(inbox["name"]),
+			channel: channelOf(inbox["channel"])
+		} : null,
+		lastReadAt: nullableInstant(row["last_read_at"]),
+		contactReadAt: nullableInstant(row["contact_read_at"]),
+		...typeof row["unread"] === "boolean" ? { unread: row["unread"] } : {}
+	};
+}
+function attachmentOf(value) {
+	const row = recordOrEmpty(value);
+	const path = optionalText(row["path"]);
+	const url = optionalText(row["url"]);
+	const name = optionalText(row["name"]);
+	const contentType = optionalText(row["content_type"]);
+	const size = row["size"];
+	return {
+		...path === void 0 ? {} : { path },
+		...url === void 0 ? {} : { url },
+		...name === void 0 ? {} : { name },
+		...contentType === void 0 ? {} : { contentType },
+		...typeof size === "number" ? { size } : {}
+	};
+}
+function reactionsOf(value) {
+	const out = {};
+	for (const [emoji, actors] of Object.entries(recordOrEmpty(value))) out[emoji] = stringsOf(actors);
+	return out;
+}
+function messageOf(value) {
+	const row = recordOf(value, "message");
+	const delivery = isRecord(row["delivery"]) ? row["delivery"] : void 0;
+	return {
+		id: textOf(row["id"]),
+		conversationId: textOf(row["conversation_id"]),
+		direction: row["direction"] === "outbound" ? "outbound" : "inbound",
+		kind: row["kind"] === "note" ? "note" : "message",
+		authorType: oneOf(row["author_type"], [
+			"contact",
+			"agent",
+			"bot",
+			"system"
+		], "system"),
+		authorId: nullableText(row["author_id"]),
+		body: textOf(row["body"] ?? ""),
+		format: row["format"] === "markdown" ? "markdown" : "text",
+		attachments: Array.isArray(row["attachments"]) ? row["attachments"].map(attachmentOf) : [],
+		reactions: reactionsOf(row["reactions"]),
+		mentions: stringsOf(row["mentions"]),
+		externalId: nullableText(row["external_id"]),
+		replyTo: nullableText(row["reply_to"]),
+		metadata: recordOrEmpty(row["metadata"]),
+		createdAt: requiredInstant(row["created_at"], "message.created_at"),
+		editedAt: nullableInstant(row["edited_at"]),
+		deletedAt: nullableInstant(row["deleted_at"]),
+		...row["delivery"] === void 0 ? {} : { delivery: delivery ? {
+			channel: textOf(delivery["channel"]),
+			status: deliveryStatusOf(delivery["status"]),
+			error: nullableText(delivery["error"])
+		} : null }
+	};
+}
+const deliveryStatusOf = (value) => oneOf(value, [
+	"queued",
+	"sent",
+	"delivered",
+	"read",
+	"failed"
+], "queued");
+const conversationsOf = (value) => recordsOf(value, "list_conversations").map(conversationOf);
+const messagesOf = (value) => recordsOf(value, "list_messages").map(messageOf);
+const eventsOf = (value) => recordsOf(value, "list_conversation_events").map((row) => ({
+	id: textOf(row["id"]),
+	type: textOf(row["type"]),
+	actorId: nullableText(row["actor_id"]),
+	data: recordOrEmpty(row["data"]),
+	createdAt: requiredInstant(row["created_at"], "event.created_at")
+}));
+function countsOf(value) {
+	const row = recordOf(value, "inbox_counts");
+	return {
+		open: Number(row["open"] ?? 0),
+		mine: Number(row["mine"] ?? 0),
+		unassigned: Number(row["unassigned"] ?? 0),
+		unread: Number(row["unread"] ?? 0)
+	};
+}
+function purgedOf(value) {
+	const row = recordOf(value, "purge_contact");
+	const paths = row["attachments"];
+	return {
+		conversations: Number(row["conversations"] ?? 0),
+		messages: Number(row["messages"] ?? 0),
+		attachments: Array.isArray(paths) ? paths.filter((path) => typeof path === "string") : []
+	};
+}
+function inboundOf(value) {
+	const row = recordOf(value, "record_inbound");
+	return {
+		conversationId: textOf(row["conversation_id"]),
+		messageId: textOf(row["message_id"]),
+		contactId: textOf(row["contact_id"]),
+		tenant: textOf(row["tenant_id"]),
+		created: row["created"] === true,
+		duplicate: row["duplicate"] === true
+	};
+}
+function templateOf(value) {
+	const row = recordOf(value, "message_template");
+	return {
+		id: textOf(row["id"]),
+		tenant: textOf(row["tenant_id"]),
+		inboxId: nullableText(row["inbox_id"]),
+		name: textOf(row["name"]),
+		channel: textOf(row["channel"]),
+		language: textOf(row["language"]),
+		body: textOf(row["body"]),
+		variables: stringsOf(row["variables"]),
+		externalId: nullableText(row["external_id"])
+	};
+}
+const storedEventsOf = (value) => recordsOf(value, "pending_inbound_events").map((row) => {
+	const headers = {};
+	for (const [key, header] of Object.entries(recordOrEmpty(row["headers"]))) headers[key] = textOf(header);
+	return {
+		id: textOf(row["id"]),
+		adapter: textOf(row["adapter"]),
+		externalId: nullableText(row["external_id"]),
+		inboxId: nullableText(row["inbox_id"]),
+		tenant: nullableText(row["tenant_id"]),
+		headers,
+		body: textOf(row["body"]),
+		attempts: Number(row["attempts"] ?? 0),
+		receivedAt: requiredInstant(row["received_at"], "inbound_event.received_at")
+	};
+});
+//#endregion
+//#region src/blocks/inbox/inbox.ts
+function contactArg(input) {
+	return {
+		id: input.id,
+		user_id: input.userId,
+		name: input.name,
+		email: input.email,
+		phone: input.phone,
+		avatar_url: input.avatarUrl,
+		metadata: input.metadata,
+		external_id: input.externalId,
+		identity: input.identity && {
+			channel: input.identity.channel,
+			external_id: input.identity.externalId
+		}
+	};
+}
+function messageArg(input) {
+	return {
+		body: input.body,
+		kind: input.kind,
+		format: input.format,
+		attachments: input.attachments?.map((file) => ({
+			path: file.path,
+			url: file.url,
+			name: file.name,
+			content_type: file.contentType,
+			size: file.size
+		})),
+		mentions: input.mentions,
+		reply_to: input.replyTo,
+		external_id: input.externalId,
+		metadata: input.metadata,
+		author_type: input.authorType,
+		delivered_by_caller: input.deliveredByCaller
+	};
+}
+/** Drops `undefined` so the jsonb input only carries what the caller set. */
+function conversationCursor(cursor) {
+	return cursor && {
+		id: cursor.id,
+		last_message_at: cursor.lastMessageAt?.toString()
+	};
+}
+function compact(value) {
+	const out = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (item === void 0) continue;
+		out[key] = isRecord(item) && Object.getPrototypeOf(item) === Object.prototype ? compact(item) : item;
+	}
+	return out;
+}
+/**
+* The `inbox` SQL module as typed calls: inboxes, contacts, conversations,
+* messages and notes, assignment, bot hand-off, read state, deliveries and
+* the stored webhook events. The database checks every permission.
+*/
+function createInbox(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema ?? "better_supabase", options.mappers);
+	const startArg = (input) => compact({
+		contact: typeof input.contact === "string" ? input.contact : input.contact && contactArg(input.contact),
+		subject: input.subject,
+		priority: input.priority,
+		bot_mode: input.botMode,
+		thread_id: input.threadId,
+		assignee_id: input.assigneeId,
+		metadata: input.metadata,
+		message: typeof input.message === "string" ? input.message : input.message && messageArg(input.message)
+	});
+	const setStatus = (conversationId, status, snoozedUntil) => call("set_conversation_status", {
+		conversation: conversationId,
+		status,
+		snoozed_until: instantArg(snoozedUntil)
+	}, conversationOf);
+	const setBotMode = (conversationId, mode, reason) => call("set_bot_mode", {
+		conversation: conversationId,
+		mode,
+		reason
+	}, conversationOf);
+	const send = (conversationId, input) => call("send_message", {
+		conversation: conversationId,
+		input: compact(messageArg(input))
+	}, messageOf);
+	return {
+		inboxes: {
+			create: (input) => call("create_inbox", {
+				tenant: input.tenant,
+				name: input.name,
+				channel: input.channel,
+				settings: input.settings,
+				bot_mode: input.botMode,
+				address: input.address
+			}, inboxOf),
+			update: (id, patch) => call("update_inbox", {
+				inbox: id,
+				patch: compact({
+					name: patch.name,
+					bot_mode: patch.botMode,
+					settings: patch.settings,
+					address: patch.address,
+					installation_id: patch.installationId,
+					archived: patch.archived
+				})
+			}, inboxOf),
+			setMember: (inboxId, userId, role) => call("set_inbox_member", {
+				inbox: inboxId,
+				member: userId,
+				role
+			}, (value) => value === true),
+			createTeam: (tenant, name) => call("create_inbox_team", {
+				tenant,
+				name
+			}, (value) => {
+				const row = recordOf(value, "create_inbox_team");
+				return {
+					id: textOf(row["id"]),
+					name: textOf(row["name"])
+				};
+			}),
+			setTeamMember: (teamId, userId, present = true) => call("set_inbox_team_member", {
+				team: teamId,
+				member: userId,
+				present
+			}, (value) => value === true)
+		},
+		contacts: { upsert: (tenant, input) => call("upsert_contact", {
+			tenant,
+			input: compact(contactArg(input))
+		}, contactOf) },
+		conversations: {
+			open: (inboxId, input = {}) => call("start_conversation", {
+				inbox: inboxId,
+				input: startArg(input)
+			}, conversationOf),
+			list: (tenant, filter = {}) => call("list_conversations", {
+				tenant,
+				filter: compact({
+					inbox_id: filter.inboxId,
+					status: filter.status,
+					assignee: filter.assignee,
+					team_id: filter.teamId,
+					contact_id: filter.contactId,
+					search: filter.search,
+					before: conversationCursor(pageOf(filter).cursor),
+					limit: filter.limit
+				})
+			}, conversationsOf),
+			get: (conversationId) => call("get_conversation", { conversation: conversationId }, (value) => value === null ? null : conversationOf(value)),
+			assign: (conversationId, to) => call("assign_conversation", {
+				conversation: conversationId,
+				assignee: to.assigneeId,
+				team: to.teamId ?? null
+			}, conversationOf),
+			setStatus: (conversationId, status, statusOptions = {}) => setStatus(conversationId, status, statusOptions.snoozedUntil),
+			snooze: (conversationId, until) => setStatus(conversationId, "snoozed", until),
+			resolve: (conversationId) => setStatus(conversationId, "resolved"),
+			reopen: (conversationId) => setStatus(conversationId, "open"),
+			handoff: (conversationId, reason) => setBotMode(conversationId, "human", reason),
+			setBotMode,
+			markRead: (conversationId) => call("mark_conversation_read", { conversation: conversationId }, (value) => {
+				if (typeof value !== "string" && !(value instanceof Date)) throw new TypeError("mark_conversation_read returned no time");
+				return toInstant(value);
+			}),
+			typing: (conversationId, typing = true, actor) => call("set_typing", {
+				conversation: conversationId,
+				typing,
+				actor
+			}, (value) => value === true),
+			events: (conversationId) => call("list_conversation_events", { conversation: conversationId }, eventsOf),
+			counts: (tenant) => call("inbox_counts", { tenant }, countsOf)
+		},
+		messages: {
+			send,
+			note: (conversationId, body, input = {}) => send(conversationId, {
+				...input,
+				body,
+				kind: "note"
+			}),
+			list: (conversationId, page = {}) => call("list_messages", {
+				conversation: conversationId,
+				before: instantArg(pageOf(page).cursor),
+				max: page.limit
+			}, messagesOf),
+			get: (messageId) => call("get_message", { message: messageId }, (value) => value === null ? null : messageOf(value)),
+			edit: (messageId, body) => call("edit_message", {
+				message: messageId,
+				body
+			}, messageOf),
+			remove: (messageId) => call("edit_message", {
+				message: messageId,
+				remove: true
+			}, messageOf),
+			react: (messageId, emoji, reactOptions = {}) => call("react_to_message", {
+				message: messageId,
+				emoji,
+				present: reactOptions.present ?? true,
+				actor: reactOptions.actor
+			}, reactionsOf)
+		},
+		deliveries: {
+			record: (input) => call("record_delivery", {
+				message: input.messageId,
+				channel: input.channel,
+				external_id: input.externalId,
+				status: input.status,
+				error: input.error
+			}, () => void 0),
+			setStatus: (input) => call("set_delivery_status", {
+				channel: input.channel,
+				external_id: input.externalId,
+				status: input.status,
+				error: input.error
+			}, Number)
+		},
+		templates: {
+			upsert: (tenant, input) => call("upsert_message_template", {
+				tenant,
+				input: compact({
+					name: input.name,
+					channel: input.channel,
+					body: input.body,
+					language: input.language,
+					inbox_id: input.inboxId,
+					variables: input.variables,
+					external_id: input.externalId
+				})
+			}, templateOf),
+			delete: (id) => call("delete_message_template", { template: id }, (value) => value === true)
+		},
+		inbound: {
+			record: (input) => call("record_inbound", { input: compact({
+				inbox_id: input.inboxId,
+				thread_id: input.threadId,
+				contact: contactArg(input.contact),
+				message: messageArg(input.message),
+				subject: input.subject,
+				direction: input.direction,
+				metadata: input.metadata
+			}) }, inboundOf),
+			store: (input) => call("store_inbound_event", {
+				adapter: input.adapter,
+				body: input.body,
+				external_id: input.externalId,
+				headers: input.headers,
+				inbox: input.inboxId,
+				tenant: input.tenant
+			}, (value) => {
+				const row = recordOf(value, "store_inbound_event");
+				return {
+					id: textOf(row["id"]),
+					duplicate: row["duplicate"] === true
+				};
+			}),
+			setStatus: (id, status, error) => call("set_inbound_event_status", {
+				event: id,
+				status,
+				error
+			}, (value) => value === true),
+			pending: (pending = {}) => call("pending_inbound_events", {
+				max: pending.limit,
+				max_attempts: pending.maxAttempts
+			}, storedEventsOf),
+			purge: (purge = {}) => call("purge_inbound_events", {
+				older_than: purge.olderThan === void 0 ? void 0 : seconds(purge.olderThan),
+				batch: purge.batch
+			}, Number)
+		},
+		wakeSnoozed: () => call("wake_snoozed_conversations", {}, Number),
+		purgeContact: (contactId) => call("purge_contact", { contact: contactId }, purgedOf)
+	};
+}
+//#endregion
+export { INBOX_CHANNELS, createInbox, rpcTransport, sqlTransport };

package/dist/blocks/inbox/react/index.d.ts

@@ -0,0 +1,2 @@
+import { a as UseConversationOptions, c as useConversation, i as InboxWidgetState, l as useInbox, n as InboxListState, o as UseInboxOptions, r as InboxSource, s as UseInboxWidgetOptions, t as ConversationState, u as useInboxWidget } from "../../../index-ACiNPN4Z.js";
+export { ConversationState, InboxListState, InboxSource, InboxWidgetState, UseConversationOptions, UseInboxOptions, UseInboxWidgetOptions, useConversation, useInbox, useInboxWidget };