better-supabase 0.13.0 → 0.15.0

package/dist/blocks/messaging/index.js

@@ -0,0 +1,619 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { t as messagingSqlOptions } from "../../options-2EMA_x6_.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+import { i as num, n as editOf, r as messageOf, t as conversationTopic } from "../../rows-BDLZStp4.js";
+import { a as mentionSegments, c as userMention, i as isFileAnchor, n as messageInputSchema, o as parseMentions, r as fileAnchor, s as recordMention, t as messageChangeSchema } from "../../schemas-l2aF78zQ.js";
+//#region src/blocks/messaging/summaries.ts
+/** The most messages one summary reads. */
+const MAX_SUMMARY_MESSAGES = 200;
+function threadSummaryOf(value) {
+	const row = recordOf(value, "thread summary");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		conversationId: textOf(row["conversation_id"]),
+		threadId: optionalText(row["thread_id"]),
+		summary: textOf(row["summary"]),
+		model: optionalText(row["model"]),
+		messageCount: num(row["message_count"]),
+		throughAt: requiredInstant(row["through_at"], "throughAt"),
+		stale: row["stale"] === true,
+		createdAt: requiredInstant(row["created_at"], "createdAt"),
+		updatedAt: requiredInstant(row["updated_at"], "updatedAt")
+	};
+}
+const summaryMessageOf = (message) => ({
+	id: message.id,
+	authorId: message.authorId,
+	authorName: message.author?.name,
+	body: message.body,
+	sentAt: message.sentAt
+});
+/**
+* Returns the saved summary while it is current, or reads the messages as the
+* caller, asks `summarizer` and saves what it wrote.
+*/
+function summarize(steps, target, summarizer, options = {}) {
+	const max = Math.min(Math.max(Math.trunc(options.maxMessages ?? MAX_SUMMARY_MESSAGES), 1), MAX_SUMMARY_MESSAGES);
+	return steps.current(target).andThen((saved) => {
+		if (saved !== void 0 && !saved.stale && options.force !== true) return AsyncResult.ok(saved);
+		return steps.read(target, max).andThen((read) => {
+			const sent = read.filter((message) => message.kind === "message" && message.sentAt !== void 0 && message.deletedAt === void 0 && message.body.trim() !== "");
+			const first = sent[0];
+			if (first === void 0) return AsyncResult.err(dbError("invalid_input", "There are no messages to summarize", { code: "MESSAGING_SUMMARY_EMPTY" }));
+			const messages = sent.map(summaryMessageOf);
+			const newest = messages.at(-1);
+			return AsyncResult.from(async () => ok(await summarizer.summarize({
+				organizationId: first.organizationId,
+				conversationId: first.conversationId,
+				threadId: "threadId" in target ? target.threadId : void 0,
+				messages,
+				previous: saved?.summary,
+				...options.signal === void 0 ? {} : { signal: options.signal }
+			}))).andThen((output) => steps.save(target, {
+				...output,
+				messageCount: messages.length,
+				throughAt: newest.sentAt
+			}));
+		});
+	});
+}
+//#endregion
+//#region src/blocks/messaging/messaging.ts
+const KINDS = [
+	"channel",
+	"dm",
+	"group_dm",
+	"subject",
+	"inbox"
+];
+const ACCESS = [
+	"members",
+	"tenant",
+	"subject"
+];
+const NOTIFY = [
+	"all",
+	"mentions",
+	"none"
+];
+function conversationOf(value) {
+	const row = recordOf(value, "conversation");
+	const subjectType = optionalText(row["subject_type"]);
+	const subjectId = optionalText(row["subject_id"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		kind: enumOrThrow(row["kind"], KINDS, "conversation kind"),
+		access: enumOrThrow(row["access"], ACCESS, "conversation access"),
+		subject: subjectType === void 0 || subjectId === void 0 ? void 0 : {
+			type: subjectType,
+			id: subjectId
+		},
+		title: optionalText(row["title"]),
+		createdBy: optionalText(row["created_by"]),
+		lastMessageAt: optionalInstant(row["last_message_at"]),
+		archivedAt: optionalInstant(row["archived_at"]),
+		createdAt: requiredInstant(row["created_at"], "createdAt"),
+		updatedAt: requiredInstant(row["updated_at"], "updatedAt")
+	};
+}
+function summaryOf(value) {
+	const row = recordOf(value, "conversation");
+	return {
+		...conversationOf(row),
+		unread: num(row["unread"]),
+		mentions: num(row["mentions"]),
+		lastReadAt: optionalInstant(row["lastReadAt"]),
+		notify: enumOrThrow(row["notify"] ?? "all", NOTIFY, "notify level")
+	};
+}
+function mentionOf(value) {
+	const row = recordOf(value, "record mention");
+	const conversation = recordOf(row["conversation"], "conversation");
+	const subjectType = optionalText(conversation["subject_type"]);
+	const subjectId = optionalText(conversation["subject_id"]);
+	return {
+		message: messageOf(row["message"]),
+		conversation: {
+			id: textOf(conversation["id"]),
+			kind: enumOrThrow(conversation["kind"], KINDS, "conversation kind"),
+			title: optionalText(conversation["title"]),
+			subject: subjectType === void 0 || subjectId === void 0 ? void 0 : {
+				type: subjectType,
+				id: subjectId
+			}
+		}
+	};
+}
+const cursorArgs = (prefix, cursor) => ({
+	[prefix]: cursor === void 0 ? null : instantArg(cursor.sentAt),
+	[`${prefix}_id`]: cursor?.id ?? null
+});
+/**
+* The messaging block: channels, direct and group messages and record
+* conversations, with threads, mentions, edits, pins, resolved threads,
+* scheduled sends, read markers, files and reactions.
+*/
+function createMessaging(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = options.service ? blockCall(options.service, options.schema, options.mappers) : call;
+	const tenant = () => requireOrganization(options.tenant);
+	const fields = blockFields(options.fields, "message fields");
+	const one = (fn, args) => call(fn, args, messageOf).andThen(fields.row);
+	const many = (fn, args) => call(fn, args, (value) => recordsOf(value, fn).map(messageOf)).andThen(fields.rows);
+	const open = (conversation) => tenant().andThen((organizationId) => call("open_conversation", {
+		tenant: organizationId,
+		kind: conversation.kind,
+		attrs: {
+			...conversation.title === void 0 ? {} : { title: conversation.title },
+			...conversation.access === void 0 ? {} : { access: conversation.access },
+			...conversation.subject === void 0 ? {} : {
+				subjectType: conversation.subject.type,
+				subjectId: conversation.subject.id
+			}
+		},
+		members: [...conversation.memberIds ?? []]
+	}, conversationOf));
+	const targetArgs = (target) => "threadId" in target ? {
+		conversation: null,
+		thread: target.threadId
+	} : {
+		conversation: target.conversationId,
+		thread: null
+	};
+	const currentSummary = (target) => call("thread_summary", targetArgs(target), (value) => value === null || value === void 0 ? void 0 : threadSummaryOf(value));
+	/** A thread's root and its newest replies, oldest first. */
+	const readThread = (threadId, max, replies = [], after) => many("list_replies", {
+		message: threadId,
+		...cursorArgs("after", after),
+		max_rows: 500
+	}).andThen((page) => {
+		const all = [...replies, ...page];
+		const last = page.at(-1);
+		if (page.length === 500 && last?.sentAt !== void 0) return readThread(threadId, max, all, {
+			sentAt: last.sentAt,
+			id: last.id
+		});
+		return one("get_message", { message: threadId }).map((root) => [root, ...all.slice(-(max - 1))]);
+	});
+	const steps = {
+		current: currentSummary,
+		read: (target, max) => "threadId" in target ? readThread(target.threadId, max) : many("list_messages", {
+			conversation: target.conversationId,
+			...cursorArgs("after", void 0),
+			...cursorArgs("before", void 0),
+			max_rows: max
+		}).map((messages) => messages.filter((message) => message.threadId === void 0)),
+		save: (target, saved) => service("save_thread_summary", {
+			...targetArgs(target),
+			summary: saved.summary,
+			attrs: {
+				messageCount: saved.messageCount,
+				throughAt: saved.throughAt.toString(),
+				...saved.model === void 0 ? {} : { model: saved.model }
+			}
+		}, threadSummaryOf)
+	};
+	return withBlockHooks({
+		open,
+		openDirect: (userIds) => open({
+			kind: new Set(userIds).size > 1 ? "group_dm" : "dm",
+			memberIds: userIds
+		}),
+		openSubject: (subject) => open({
+			kind: "subject",
+			subject
+		}),
+		addMembers: (conversationId, userIds) => call("add_conversation_members", {
+			conversation: conversationId,
+			users: [...userIds]
+		}, num),
+		removeMember: (conversationId, userId) => call("remove_conversation_member", {
+			conversation: conversationId,
+			member: userId
+		}, (value) => value === true),
+		archive: (conversationId, archived = true) => call("archive_conversation", {
+			conversation: conversationId,
+			archived
+		}, (value) => value === true),
+		conversations: (list = {}) => tenant().andThen((organizationId) => call("list_conversations", {
+			tenant: organizationId,
+			kinds: list.kinds === void 0 ? null : [...list.kinds],
+			max_rows: list.limit ?? null
+		}, (value) => recordsOf(value, "list_conversations").map(summaryOf))),
+		unreadCounts: () => tenant().andThen((organizationId) => call("unread_counts", { tenant: organizationId }, (value) => Object.fromEntries(Object.entries(recordOf(value, "unread_counts")).map(([id, count]) => {
+			const row = recordOf(count, "unread count");
+			return [id, {
+				unread: num(row["unread"]),
+				mentions: num(row["mentions"])
+			}];
+		})))),
+		markRead: (conversationId, read = {}) => call("mark_read", {
+			conversation: conversationId,
+			thread: read.threadId ?? null,
+			read_at: instantArg(read.readAt) ?? null
+		}, (value) => requiredInstant(value, "readAt")),
+		setNotify: (conversationId, level) => call("set_conversation_notify", {
+			conversation: conversationId,
+			level
+		}, (value) => value === true),
+		typing: (conversationId, typing = true) => call("set_typing", {
+			conversation: conversationId,
+			typing
+		}, (value) => value === true),
+		follow: (target, following = true) => call("follow", "conversationId" in target ? {
+			target_type: "conversation",
+			target_id: target.conversationId,
+			following
+		} : {
+			target_type: "thread",
+			target_id: target.threadId,
+			following
+		}, (value) => value === true),
+		can: (conversationId, action) => call("can_conversation", {
+			conversation: conversationId,
+			action
+		}, (value) => value === true),
+		send: (conversationId, message) => fields.args(message.fields).andThen((checked) => one("send_message", {
+			conversation: conversationId,
+			body: message.body,
+			attrs: {
+				...message.parentId === void 0 ? {} : { parentId: message.parentId },
+				...message.document === void 0 ? {} : { document: message.document },
+				...message.anchor === void 0 ? {} : { anchor: message.anchor },
+				...message.mentionIds === void 0 ? {} : { mentions: [...message.mentionIds] },
+				...message.broadcast === void 0 ? {} : { broadcast: message.broadcast },
+				...message.scheduledFor === void 0 ? {} : { scheduledFor: message.scheduledFor.toString() },
+				...checked === void 0 ? {} : { fields: checked }
+			},
+			attachments: [...message.attachmentIds ?? []]
+		})),
+		edit: (messageId, edition) => fields.args(edition.fields).andThen((checked) => one("edit_message", {
+			message: messageId,
+			body: edition.body,
+			attrs: {
+				...edition.document === void 0 ? {} : { document: edition.document },
+				...edition.mentionIds === void 0 ? {} : { mentions: [...edition.mentionIds] },
+				...checked === void 0 ? {} : { fields: checked }
+			}
+		})),
+		remove: (messageId) => call("delete_message", { message: messageId }, (value) => value === true),
+		pin: (messageId, pinned = true) => one("pin_message", {
+			message: messageId,
+			pinned
+		}),
+		resolve: (messageId, resolved = true) => one("resolve_message", {
+			message: messageId,
+			resolved
+		}),
+		list: (conversationId, list = {}) => many("list_messages", {
+			conversation: conversationId,
+			...cursorArgs("after", list.after),
+			...cursorArgs("before", list.before),
+			max_rows: list.limit ?? null
+		}),
+		replies: (messageId, list = {}) => many("list_replies", {
+			message: messageId,
+			...cursorArgs("after", list.after),
+			max_rows: list.limit ?? null
+		}),
+		anchoredTo: (attachmentId, list = {}) => many("list_file_anchors", {
+			attachment: attachmentId,
+			max_rows: list.limit ?? null
+		}),
+		get: (messageId) => call("get_message", { message: messageId }, (value) => value === null || value === void 0 ? void 0 : messageOf(value)).andThen((message) => message === void 0 ? fields.rows([]).map(() => void 0) : fields.row(message)),
+		edits: (messageId) => call("list_message_edits", { message: messageId }, (value) => recordsOf(value, "list_message_edits").map(editOf)),
+		pinned: (conversationId) => many("list_pinned_messages", { conversation: conversationId }),
+		recordMentions: (subject, list = {}) => call("list_record_mentions", {
+			subject_type: subject.type,
+			subject_id: subject.id,
+			...cursorArgs("before", list.before),
+			max_rows: list.limit ?? null
+		}, (value) => recordsOf(value, "list_record_mentions").map(mentionOf)).andThen((found) => fields.rows(found.map((item) => item.message)).map((messages) => found.map((item, index) => ({
+			conversation: item.conversation,
+			message: messages[index]
+		})))),
+		publishDue: (limit) => call("publish_due_messages", { max_rows: limit ?? null }, num),
+		summary: currentSummary,
+		summarize: (target, summarizer, summarizeOptions) => summarize(steps, target, summarizer, summarizeOptions)
+	}, options.hooks, {
+		block: "messaging",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/messaging/client.ts
+const TYPING_EVENT = "typing";
+/** How often a held `setTyping(true)` broadcasts again. */
+const TYPING_RESEND_MS = 3e3;
+const order = (a, b) => {
+	const left = (a.sentAt ?? a.createdAt).epochMilliseconds;
+	const right = (b.sentAt ?? b.createdAt).epochMilliseconds;
+	if (left !== right) return left - right;
+	return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+};
+/** `messages` with `incoming` added or replaced, oldest first. */
+function merge(messages, incoming) {
+	const byId = new Map(messages.map((message) => [message.id, message]));
+	for (const message of incoming) byId.set(message.id, message);
+	return [...byId.values()].toSorted(order);
+}
+const text = (value) => typeof value === "string" ? value : void 0;
+/**
+* One conversation, or one thread, for the signed-in user: loads the latest
+* page, keeps it current from the conversation's Realtime pings, tracks who is
+* typing, and moves the read marker as messages arrive.
+*/
+function createMessagesController(options) {
+	const { client, conversationId } = options;
+	const threadId = options.threadId ?? null;
+	const limit = options.limit ?? 50;
+	const autoRead = options.markRead ?? true;
+	const typingTimeout = options.typingTimeout ?? 6e3;
+	return defineController({
+		messages: void 0,
+		hasOlder: false,
+		typing: [],
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		let handle;
+		let me;
+		let typingSentAt = 0;
+		const typers = /* @__PURE__ */ new Map();
+		const shows = (message) => message.conversationId === conversationId && (threadId === null ? message.threadId === void 0 || message.broadcast : message.threadId === threadId);
+		const page = (before) => threadId === null ? client.list(conversationId ?? "", {
+			limit,
+			...before?.sentAt === void 0 ? {} : { before: {
+				sentAt: before.sentAt,
+				id: before.id
+			} }
+		}) : client.replies(threadId, { limit });
+		const markRead = async () => {
+			if (conversationId === null) return;
+			await client.markRead(conversationId, threadId === null ? {} : { threadId });
+		};
+		const put = (incoming) => {
+			state.set((current) => ({
+				error: void 0,
+				messages: merge(current.messages ?? [], incoming.filter(shows))
+			}));
+		};
+		const refresh = async () => {
+			if (conversationId === null) return;
+			ticket += 1;
+			const request = ticket;
+			const result = await page();
+			if (request !== ticket) return;
+			if (!result.ok) {
+				state.set({ error: result.error });
+				return;
+			}
+			state.set({
+				messages: merge([], result.data),
+				hasOlder: threadId === null && result.data.length >= limit,
+				error: void 0
+			});
+			if (autoRead) await markRead();
+		};
+		const stopTyping = (userId) => {
+			clearTimeout(typers.get(userId));
+			if (typers.delete(userId)) state.set({ typing: [...typers.keys()] });
+		};
+		const heard = (userId, typing) => {
+			if (userId === me) return;
+			stopTyping(userId);
+			if (typing) {
+				typers.set(userId, setTimeout(() => {
+					stopTyping(userId);
+				}, typingTimeout));
+				state.set({ typing: [...typers.keys()] });
+			}
+		};
+		const ping = async (event, payload) => {
+			const data = isRecord(payload) ? payload : {};
+			if (event === TYPING_EVENT) {
+				const userId = text(data["userId"]);
+				if (userId !== void 0) heard(userId, data["typing"] !== false);
+				return;
+			}
+			const messageId = text(data["messageId"]);
+			if (messageId === void 0) return;
+			const result = await client.get(messageId);
+			if (!result.ok || result.data === void 0) return;
+			const message = result.data;
+			if (message.authorId !== void 0) stopTyping(message.authorId);
+			if (!shows(message)) return;
+			put([message]);
+			if (autoRead && event === "message" && message.authorId !== me) await markRead();
+		};
+		const written = (result) => {
+			if (result.ok) {
+				ticket += 1;
+				put([result.data]);
+			} else state.set({ error: result.error });
+			return result;
+		};
+		return {
+			actions: {
+				refresh,
+				markRead,
+				send: async (body, draft = {}) => {
+					if (conversationId === null) return err(dbError("invalid_input", "No conversation is open"));
+					typingSentAt = 0;
+					handle?.send(TYPING_EVENT, {
+						conversationId,
+						userId: me,
+						typing: false
+					});
+					return written(await client.send(conversationId, {
+						...draft,
+						...threadId === null || draft.parentId !== void 0 ? {} : { parentId: threadId },
+						body
+					}));
+				},
+				edit: async (id, edition) => written(await client.edit(id, edition)),
+				remove: async (id) => {
+					const result = await client.remove(id);
+					if (result.ok) {
+						const fresh = await client.get(id);
+						if (fresh.ok && fresh.data !== void 0) put([fresh.data]);
+					} else state.set({ error: result.error });
+					return result;
+				},
+				pin: async (id, pinned = true) => written(await client.pin(id, pinned)),
+				resolve: async (id, resolved = true) => written(await client.resolve(id, resolved)),
+				loadOlder: async () => {
+					const oldest = state.get().messages?.[0];
+					if (conversationId === null || threadId !== null || oldest === void 0) return;
+					const result = await page(oldest);
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({
+						messages: merge(current.messages ?? [], result.data),
+						hasOlder: result.data.length >= limit
+					}));
+				},
+				setTyping: (typing) => {
+					if (handle === void 0 || me === void 0) return;
+					const now = Date.now();
+					if (typing && now - typingSentAt < TYPING_RESEND_MS) return;
+					typingSentAt = typing ? now : 0;
+					handle.send(TYPING_EVENT, {
+						conversationId,
+						userId: me,
+						typing
+					});
+				}
+			},
+			start: () => conversationId === null ? void 0 : whileSignedIn(options.auth, (userId) => {
+				me = userId;
+				refresh();
+				handle = options.ports.topic(conversationTopic(conversationId, options.topic), {
+					onMessage: (event, payload) => void ping(event, payload),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				});
+				return () => {
+					handle?.leave();
+					handle = void 0;
+					me = void 0;
+					for (const timer of typers.values()) clearTimeout(timer);
+					typers.clear();
+					state.set({ typing: [] });
+				};
+			})
+		};
+	});
+}
+/**
+* The caller's conversations with their unread and mention counts, loaded again
+* when a message arrives in one of them.
+*/
+function createConversationsController(options) {
+	const watch = options.watch ?? 50;
+	return defineController({
+		conversations: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const joined = /* @__PURE__ */ new Map();
+		const follow = (ids) => {
+			const wanted = new Set(ids.slice(0, watch));
+			for (const [id, handle] of joined) if (!wanted.has(id)) {
+				handle.leave();
+				joined.delete(id);
+			}
+			for (const id of wanted) if (!joined.has(id)) joined.set(id, options.ports.topic(conversationTopic(id, options.topic), {
+				onMessage: (event) => {
+					if (event === "message") refresh();
+				},
+				onRejoin: () => void 0,
+				onStatus: (status) => {
+					state.set({ status });
+				}
+			}));
+		};
+		const refresh = async () => {
+			if (!options.enabled) return;
+			ticket += 1;
+			const request = ticket;
+			const result = await options.client.conversations({
+				...options.kinds === void 0 ? {} : { kinds: options.kinds },
+				...options.limit === void 0 ? {} : { limit: options.limit }
+			});
+			if (request !== ticket) return;
+			if (result.ok) {
+				state.set({
+					conversations: result.data,
+					error: void 0
+				});
+				follow(result.data.map((conversation) => conversation.id));
+			} else state.set({ error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => options.enabled ? whileSignedIn(options.auth, () => {
+				refresh();
+				return () => {
+					follow([]);
+				};
+			}) : void 0
+		};
+	});
+}
+//#endregion
+//#region src/blocks/messaging/events.ts
+/** The `messaging` block's event types, for its manifest and `onBlockEvent`. */
+const messagingEvents = defineEvents({
+	"conversation.created": event(),
+	"conversation.archived": event(),
+	"conversation.member_added": event(),
+	"conversation.member_removed": event(),
+	"message.sent": event(),
+	"message.edited": event(),
+	"message.deleted": event(),
+	"message.pinned": event(),
+	"message.resolved": event()
+});
+//#endregion
+//#region src/blocks/messaging/manifest.ts
+/** The `messaging` block's manifest (ADR 0029, ADR 0062). */
+const messagingBlock = defineBlock({
+	name: "messaging",
+	sql: ["messaging"],
+	options: { messaging: messagingSqlOptions },
+	events: messagingEvents,
+	schemas: { message: {
+		input: messageInputSchema,
+		change: messageChangeSchema
+	} },
+	create: createMessaging,
+	client: "messaging",
+	category: "collaboration",
+	recipes: [
+		"channel-sidebar",
+		"message-composer",
+		"message-list",
+		"presence-avatars",
+		"thread-panel"
+	]
+});
+//#endregion
+export { conversationTopic, createConversationsController, createMessagesController, createMessaging, dbTransport, extendBlock, fileAnchor, isFileAnchor, mentionSegments, messageChangeSchema, messageInputSchema, messagingBlock, messagingEvents, parseMentions, recordMention, rpcTransport, sqlTransport, userMention, withBlockHooks, wrapTransport };

package/dist/blocks/metrics/index.d.ts

@@ -1,12 +1,12 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "../../result-mijqfoJN.js";
+import { t as AsyncResult } from "../../result-DZeA5KS6.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { n as BlockOptions } from "../../block-helpers-DyA5BAW4.js";
-import { n as BlockHooks } from "../../block-hooks-BadAniNI.js";
-import { g as JobHandler } from "../../types-CB5MvzuE.js";
-import { i as EventSink, t as CloudEvent } from "../../cloud-event-CidL9jiw.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
+import { n as BlockOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { g as JobHandler } from "../../types-SFRomQF7.js";
+import { c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { i as EventSink, t as CloudEvent } from "../../cloud-event-CzZTJkXv.js";
 import { a as MetricWhereValue, c as metricsOf, i as MetricMeasure, n as MetricDefinition, o as checkMetric, r as MetricGrain, s as defineMetric, t as METRIC_GRAINS } from "../../metric-definition-EAYI1r2n.js";
 //#region src/blocks/metrics/sink.d.ts
 interface MetricsSinkOptions {

package/dist/blocks/metrics/index.js

@@ -1,14 +1,13 @@
-import { s as nowInstant } from "../../temporal-DLZlWbOi.js";
-import { t as temporal } from "../../temporal-required-Dt4mcPsi.js";
-import { t as AsyncResult } from "../../result-DIT_qp4G.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { s as nowInstant } from "../../temporal-DLZlWbOi.js";
+import { t as temporal } from "../../temporal-required-Dy0GGD8E.js";
+import { t as AsyncResult } from "../../result-ntFBW2p2.js";
 import { t as metricsSqlOptions } from "../../options-CN7PHkhU.js";
 import { a as metricsOf, n as checkMetric, r as defineMetric, t as METRIC_GRAINS } from "../../metric-definition-BjxVn4R5.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, F as stringsOf, H as rpcTransport, I as textOf, U as sqlTransport, k as recordsOf, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { a as stripTypePrefix } from "../../cloud-event-XsM53POL.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-DwE32_gT.js";
-import { r as withBlockHooks } from "../../block-hooks-C1r-R2r0.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
 //#region src/blocks/metrics/metrics.ts
 /** The queue `metrics.job` handles: re-aggregates a window of rollups. */
 const METRICS_ROLLUP_QUEUE = "metrics.rollup";