@notionhq/custom-blocks-host 0.3.4 → 0.3.6

package/src/lifecycle/legacyPage.ts

@@ -0,0 +1,208 @@
+import type { NotionDataSourceValue } from "@notionhq/custom-blocks-protocol/dataSources/dataSourceValue.js"
+import type {
+	LegacyNotionPage,
+	NotionPagePropertyValue,
+	notionPageDataSchema,
+} from "@notionhq/custom-blocks-protocol/pages/page.js"
+import type { InferOutput } from "valibot"
+import { unreachable } from "../utils.js"
+
+export function toLegacyPage(
+	page: InferOutput<typeof notionPageDataSchema>,
+): LegacyNotionPage {
+	return {
+		...page,
+		properties: Object.fromEntries(
+			Object.values(page.properties).flatMap(property =>
+				property ? [[property.id, property]] : [],
+			),
+		),
+		icon: page.icon ?? undefined,
+		cover: page.cover ?? undefined,
+		created_time: page.created_time ?? undefined,
+		last_edited_time: page.last_edited_time ?? undefined,
+		url: page.url ?? undefined,
+		public_url: page.public_url ?? undefined,
+	}
+}
+
+export function toLegacyQueryPage(
+	page: InferOutput<typeof notionPageDataSchema>,
+) {
+	const propertiesById: Record<string, NotionDataSourceValue | undefined> = {}
+	for (const property of Object.values(page.properties)) {
+		if (property) {
+			propertiesById[property.id] = toLegacyProperty(property)
+		}
+	}
+	return {
+		id: page.id,
+		is_archived: page.is_archived,
+		in_trash: page.in_trash,
+		propertiesById,
+	}
+}
+
+function plainText(items: Record<string, unknown>[]): string {
+	return items
+		.map(item => {
+			if (typeof item.plain_text === "string") {
+				return item.plain_text
+			}
+			const text = item.text
+			return text &&
+				typeof text === "object" &&
+				"content" in text &&
+				typeof text.content === "string"
+				? text.content
+				: ""
+		})
+		.join("")
+}
+
+function timestamp(
+	value: string | number | null | undefined,
+): NotionDataSourceValue | undefined {
+	if (value === undefined || value === null || value === "") {
+		return undefined
+	}
+	const date = new Date(value)
+	if (!Number.isFinite(date.getTime())) {
+		return undefined
+	}
+	return {
+		type: "datetime",
+		start_date: date.toISOString().slice(0, 10),
+		start_time: date.toISOString().slice(11, 16),
+		time_zone: "UTC",
+	}
+}
+
+function legacyDate(value: {
+	start: string
+	end?: string | null
+	time_zone?: string | null
+}): NotionDataSourceValue {
+	const timed = value.start.includes("T") || value.time_zone != null
+	const offset = value.start.match(/([+-])(\d{2}):(\d{2})$/)
+	const offsetMinutes = offset
+		? (Number(offset[2]) * 60 + Number(offset[3])) *
+			(offset[1] === "-" ? -1 : 1)
+		: 0
+	const parts = (input: string) => {
+		if (!input.includes("T")) {
+			return { date: input, time: "00:00" }
+		}
+		const wallClock = input.match(
+			/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})(?::\d{2}(?:\.\d+)?)?$/,
+		)
+		if (wallClock) {
+			return { date: wallClock[1], time: wallClock[2] }
+		}
+		if (!value.time_zone) {
+			const local = new Date(
+				new Date(input).getTime() + offsetMinutes * 60_000,
+			).toISOString()
+			return { date: local.slice(0, 10), time: local.slice(11, 16) }
+		}
+		const entries = new Intl.DateTimeFormat("en-CA", {
+			timeZone: value.time_zone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23",
+		}).formatToParts(new Date(input))
+		const get = (type: string) =>
+			entries.find(part => part.type === type)?.value
+		return {
+			date: `${get("year")}-${get("month")}-${get("day")}`,
+			time: `${get("hour")}:${get("minute")}`,
+		}
+	}
+	const start = parts(value.start)
+	const end = value.end ? parts(value.end) : undefined
+	if (!timed) {
+		return end
+			? { type: "daterange", start_date: start.date, end_date: end.date }
+			: { type: "date", start_date: start.date }
+	}
+	const zone =
+		value.time_zone ??
+		(offsetMinutes === 0
+			? "UTC"
+			: `UTC${offsetMinutes < 0 ? "-" : "+"}${Math.floor(Math.abs(offsetMinutes) / 60)}${Math.abs(offsetMinutes) % 60 === 0 ? "" : `:${String(Math.abs(offsetMinutes) % 60).padStart(2, "0")}`}`)
+	return end
+		? {
+				type: "datetimerange",
+				start_date: start.date,
+				start_time: start.time,
+				end_date: end.date,
+				end_time: end.time,
+				time_zone: zone,
+			}
+		: {
+				type: "datetime",
+				start_date: start.date,
+				start_time: start.time,
+				time_zone: zone,
+			}
+}
+
+function toLegacyProperty(
+	property: NotionPagePropertyValue,
+): NotionDataSourceValue | undefined {
+	switch (property.type) {
+		case "title":
+			return plainText(property.title)
+		case "rich_text":
+			return plainText(property.rich_text)
+		case "number":
+			return property.number ?? undefined
+		case "checkbox":
+			return property.checkbox
+		case "url":
+			return property.url ?? ""
+		case "email":
+			return property.email ?? ""
+		case "phone_number":
+			return property.phone_number ?? ""
+		case "select":
+			return property.select?.name
+		case "status":
+			return property.status?.name
+		case "multi_select":
+			return property.multi_select.flatMap(option => option.name ?? [])
+		case "date":
+			return property.date ? legacyDate(property.date) : undefined
+		case "people":
+			return property.people.map(person =>
+				person.object === "group"
+					? {
+							id: person.id,
+							table: "space_permission_group",
+							spaceId: person.id.split("|")[1],
+						}
+					: { id: person.id, table: "notion_user" },
+			)
+		case "relation":
+			return property.relation.map(page => ({ id: page.id, table: "block" }))
+		case "files":
+			return property.files.map(file => file.name).join(",")
+		case "place":
+			return ""
+		case "created_time":
+			return timestamp(property.created_time)
+		case "last_edited_time":
+			return timestamp(property.last_edited_time)
+		case "last_visited_time":
+			return timestamp(property.last_visited_time)
+		case "created_by":
+			return property.created_by ? [property.created_by] : undefined
+		case "last_edited_by":
+			return property.last_edited_by ? [property.last_edited_by] : undefined
+		default:
+			return unreachable(property)
+	}
+}

package/src/lifecycle/normalizeHostToSandboxMessage.ts

@@ -1,46 +1,29 @@
-import { NOTION_BUILTIN_PROPERTY_SCHEMAS } from "@notionhq/custom-blocks-protocol/dataSources/propertySchema.js"
-import type { HostToSandboxMessage } from "@notionhq/custom-blocks-protocol/messages/hostToSandbox.js"
+import type {
+	HostToSandboxMessage,
+	HostToSandboxMessageLegacy,
+} from "@notionhq/custom-blocks-protocol/messages/hostToSandbox.js"
+import { normalizeToLegacyPage } from "./normalizePage.js"
 
 /**
  * Normalizes an outgoing message for the bridge protocol version requested by the sandbox.
  */
 // TODO(custom-blocks): Remove this function when MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION
-// reaches 5.
+// reaches 6.
 export function normalizeHostToSandboxMessage(
 	message: HostToSandboxMessage,
 	bridgeProtocolVersion: number,
-): HostToSandboxMessage {
-	// The latest SDK version does not need any normalization.
-	if (bridgeProtocolVersion >= 5) {
+): HostToSandboxMessageLegacy {
+	if (
+		message.type !== "queryDataSourceResult" &&
+		message.type !== "getPageResult" &&
+		message.type !== "createPageResult" &&
+		message.type !== "updatePageResult"
+	) {
 		return message
 	}
-	const containsDataSources =
-		(message.type === "init" && message.status === "success") ||
-		message.type === "dataSourcesChanged"
-	if (!containsDataSources) {
-		return message
-	}
-	// Protocol 5 excludes synthetic IDs such as created_time from collectionSchema.propertiesById.
-	// Older SDKs derive read schemas from that map. Restore those entries in outgoing copies so
-	// host query validation still uses the actual database schema.
-	return {
-		...message,
-		dataSources: {
-			bindings: Object.fromEntries(
-				Object.entries(message.dataSources.bindings).map(([key, binding]) => [
-					key,
-					{
-						...binding,
-						collectionSchema: {
-							...binding.collectionSchema,
-							propertiesById: {
-								...binding.collectionSchema?.propertiesById,
-								...NOTION_BUILTIN_PROPERTY_SCHEMAS,
-							},
-						},
-					},
-				]),
-			),
-		},
-	}
+	const normalizedMessage = normalizeToLegacyPage(
+		message,
+		bridgeProtocolVersion,
+	)
+	return normalizedMessage
 }

package/src/lifecycle/normalizePage.ts

@@ -0,0 +1,35 @@
+import type { CreatePageResultMessage } from "@notionhq/custom-blocks-protocol/messages/createPageResult.js"
+import type { GetPageResultMessage } from "@notionhq/custom-blocks-protocol/messages/getPage.js"
+import type { HostToSandboxMessageLegacy } from "@notionhq/custom-blocks-protocol/messages/hostToSandbox.js"
+import type { QueryDataSourceResultMessage } from "@notionhq/custom-blocks-protocol/messages/queryDataSourceResult.js"
+import type { UpdatePageResultMessage } from "@notionhq/custom-blocks-protocol/messages/updatePageResult.js"
+import { LEGACY_PROPERTY_SHAPE_PROTOCOL_VERSION } from "@notionhq/custom-blocks-protocol/protocolVersion.js"
+import { unreachable } from "../utils.js"
+import { toLegacyPage, toLegacyQueryPage } from "./legacyPage.js"
+
+export function normalizeToLegacyPage(
+	message:
+		| CreatePageResultMessage
+		| GetPageResultMessage
+		| UpdatePageResultMessage
+		| QueryDataSourceResultMessage,
+	bridgeProtocolVersion: number,
+): HostToSandboxMessageLegacy {
+	// Forward up to date messages
+	if (bridgeProtocolVersion >= LEGACY_PROPERTY_SHAPE_PROTOCOL_VERSION) {
+		return message
+	}
+	if (message.status === "error") {
+		return message
+	}
+	switch (message.type) {
+		case "queryDataSourceResult":
+			return { ...message, items: message.items.map(toLegacyQueryPage) }
+		case "getPageResult":
+		case "createPageResult":
+		case "updatePageResult":
+			return { ...message, page: toLegacyPage(message.page) }
+		default:
+			return unreachable(message)
+	}
+}

package/src/messages/types.ts

@@ -57,7 +57,7 @@ import type {
 import type { InferInput } from "valibot"
 import type { CustomBlockHostQueryDataSourceResult } from "../queries/types.js"
 
-type MaybePromise<T> = T | Promise<T>
+export type MaybePromise<T> = T | Promise<T>
 
 /**
  * Host results use InferInput so adapters can return plain string IDs.