@notionhq/custom-blocks-host 0.0.1

package/dist/protocol/pages/page.js

@@ -0,0 +1,212 @@
+/**
+ * Notion page shapes exchanged over the custom block bridge.
+ *
+ * These mirror a narrow subset of Notion's public `POST /v1/pages` API, since that's the bridge
+ * shape the host delivers for messages like `createPageResult`.
+ */
+import * as v from "valibot";
+import { notionPageIdSchema } from "../ids.js";
+import { notionParentSchema } from "../parent.js";
+/**
+ * The custom block's nearest enclosing page ancestor, carried in `init.page` and `pageChanged`.
+ */
+export const customBlockPageSchema = v.object({
+    id: notionPageIdSchema,
+    /**
+     * The containing page's own parent. It lets a block distinguish a freestanding page from a
+     * database row without a round trip. Not to be confused with the top-level `parent` runtime
+     * value, which is the custom block's own parent.
+     */
+    parent: notionParentSchema,
+});
+export const notionEmojiIconSchema = v.object({
+    type: v.literal("emoji"),
+    emoji: v.string(),
+});
+export const notionCustomEmojiIconSchema = v.object({
+    type: v.literal("custom_emoji"),
+    custom_emoji: v.object({
+        id: v.string(),
+        name: v.optional(v.string()),
+        url: v.optional(v.string()),
+    }),
+});
+export const notionExternalFileSchema = v.object({
+    type: v.literal("external"),
+    external: v.object({ url: v.string() }),
+});
+export const notionHostedFileSchema = v.object({
+    type: v.literal("file"),
+    file: v.object({
+        url: v.string(),
+        expiry_time: v.optional(v.string()),
+    }),
+});
+// TODO(custom-blocks): Add file upload support.
+export const notionPageIconSchema = v.variant("type", [
+    notionEmojiIconSchema,
+    notionCustomEmojiIconSchema,
+    notionExternalFileSchema,
+    notionHostedFileSchema,
+]);
+export const notionPageCoverSchema = v.variant("type", [
+    notionExternalFileSchema,
+    notionHostedFileSchema,
+]);
+const nullableStringSchema = v.nullable(v.string());
+const notionRichTextItemSchema = v.record(v.string(), v.unknown());
+const notionSelectOptionInputSchema = v.union([
+    v.object({
+        id: v.string(),
+        name: v.optional(v.string()),
+        color: v.optional(v.string()),
+        description: v.optional(nullableStringSchema),
+    }),
+    v.object({
+        name: v.string(),
+        id: v.optional(v.string()),
+        color: v.optional(v.string()),
+        description: v.optional(nullableStringSchema),
+    }),
+]);
+const notionDateInputSchema = v.object({
+    start: v.string(),
+    end: v.optional(nullableStringSchema),
+    time_zone: v.optional(nullableStringSchema),
+});
+const notionUserInputSchema = v.union([
+    v.object({
+        object: v.optional(v.literal("user")),
+        id: v.string(),
+    }),
+    v.object({
+        object: v.literal("group"),
+        id: v.string(),
+        name: v.optional(nullableStringSchema),
+    }),
+]);
+const notionRelationInputSchema = v.object({ id: v.string() });
+const notionFileInputSchema = v.union([
+    v.object({
+        type: v.literal("external"),
+        name: v.string(),
+        external: v.object({ url: v.string() }),
+    }),
+    v.object({
+        type: v.literal("file"),
+        name: v.string(),
+        file: v.object({
+            url: v.string(),
+            expiry_time: v.optional(v.string()),
+        }),
+    }),
+]);
+const notionPlaceInputSchema = v.object({
+    lat: v.number(),
+    lon: v.number(),
+    name: v.optional(nullableStringSchema),
+    address: v.optional(nullableStringSchema),
+    aws_place_id: v.optional(nullableStringSchema),
+    google_place_id: v.optional(nullableStringSchema),
+});
+const pagePropertyBaseSchema = {
+    id: v.string(),
+};
+/**
+ * A page property value.
+ */
+export const notionPagePropertyValueSchema = v.variant("type", [
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("title"),
+        title: v.array(notionRichTextItemSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("rich_text"),
+        rich_text: v.array(notionRichTextItemSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("number"),
+        number: v.nullable(v.number()),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("url"),
+        url: nullableStringSchema,
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("email"),
+        email: nullableStringSchema,
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("phone_number"),
+        phone_number: nullableStringSchema,
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("checkbox"),
+        checkbox: v.boolean(),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("select"),
+        select: v.nullable(notionSelectOptionInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("status"),
+        status: v.nullable(notionSelectOptionInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("multi_select"),
+        multi_select: v.array(notionSelectOptionInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("date"),
+        date: v.nullable(notionDateInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("people"),
+        people: v.array(notionUserInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("relation"),
+        has_more: v.optional(v.boolean()),
+        relation: v.array(notionRelationInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("files"),
+        files: v.array(notionFileInputSchema),
+    }),
+    v.object({
+        ...pagePropertyBaseSchema,
+        type: v.literal("place"),
+        place: v.nullable(notionPlaceInputSchema),
+    }),
+]);
+export const notionPagePropertyWriteMapSchema = v.record(v.string(), notionPagePropertyValueSchema);
+/**
+ * The `Page` object returned in `createPageResult` messages.
+ */
+export const notionPageSchema = v.object({
+    object: v.literal("page"),
+    id: notionPageIdSchema,
+    parent: notionParentSchema,
+    properties: notionPagePropertyWriteMapSchema,
+    created_time: v.optional(v.string()),
+    last_edited_time: v.optional(v.string()),
+    icon: v.optional(notionPageIconSchema),
+    cover: v.optional(notionPageCoverSchema),
+    url: v.optional(v.string()),
+    public_url: v.optional(v.string()),
+    in_trash: v.optional(v.boolean()),
+});

package/dist/protocol/parent.d.ts

@@ -0,0 +1,28 @@
+import * as v from "valibot";
+export declare const notionParentSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"page_id", undefined>;
+    readonly page_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionPageId">]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"data_source_id", undefined>;
+    readonly data_source_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionDataSourceId">]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"workspace", undefined>;
+    readonly workspace: v.LiteralSchema<true, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"block_id", undefined>;
+    readonly block_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionBlockId">]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"agent_id", undefined>;
+    readonly agent_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionAgentId">]>;
+}, undefined>], undefined>;
+/**
+ * A record's parent reference.
+ *
+ * Mirrors Notion's public API:
+ * - `page_id` — parented directly under a page.
+ * - `block_id` — parented under a non-page container block (toggle, column, callout, ...).
+ * - `data_source_id` — parented under a collection (data source).
+ * - `workspace` — top-level / team-rooted.
+ * - `agent_id` — owned by an agent, such as an agent instruction page or its blocks.
+ */
+export type NotionParent = v.InferOutput<typeof notionParentSchema>;

package/dist/protocol/parent.js

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+import { notionAgentIdSchema, notionBlockIdSchema, notionDataSourceIdSchema, notionPageIdSchema, } from "./ids.js";
+export const notionParentSchema = v.variant("type", [
+    v.object({ type: v.literal("page_id"), page_id: notionPageIdSchema }),
+    v.object({
+        type: v.literal("data_source_id"),
+        data_source_id: notionDataSourceIdSchema,
+    }),
+    v.object({ type: v.literal("workspace"), workspace: v.literal(true) }),
+    v.object({ type: v.literal("block_id"), block_id: notionBlockIdSchema }),
+    v.object({ type: v.literal("agent_id"), agent_id: notionAgentIdSchema }),
+]);

package/dist/protocol/protocolVersion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Used to ensure that the host and client are using the same version of the bridge protocol. A
+ * single host needs to support multiple custom blocks built with different versions of the bridge
+ * protocol. Increment this number any time a breaking change is made to the bridge protocol.
+ */
+export declare const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 3;

package/dist/protocol/protocolVersion.js

@@ -0,0 +1,6 @@
+/**
+ * Used to ensure that the host and client are using the same version of the bridge protocol. A
+ * single host needs to support multiple custom blocks built with different versions of the bridge
+ * protocol. Increment this number any time a breaking change is made to the bridge protocol.
+ */
+export const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 3;

package/dist/protocol/theme.d.ts

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export declare const notionThemeSchema: v.PicklistSchema<["light", "dark"], undefined>;
+export type NotionTheme = v.InferOutput<typeof notionThemeSchema>;

package/dist/protocol/theme.js

@@ -0,0 +1,2 @@
+import * as v from "valibot";
+export const notionThemeSchema = v.picklist(["light", "dark"]);

package/dist/protocol/users/user.d.ts

@@ -0,0 +1,32 @@
+import * as v from "valibot";
+export declare const notionUserIdSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionUserId">]>;
+export type NotionUserId = v.InferOutput<typeof notionUserIdSchema>;
+export declare const notionUserSchema: v.ObjectSchema<{
+    readonly object: v.LiteralSchema<"user", undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionUserId">]>;
+    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly type: v.LiteralSchema<"person", undefined>;
+    readonly person: v.ObjectSchema<{
+        readonly email: v.StringSchema<undefined>;
+    }, undefined>;
+}, undefined>;
+export type NotionUser = v.InferOutput<typeof notionUserSchema>;
+export declare const notionUserListSchema: v.ObjectSchema<{
+    readonly object: v.LiteralSchema<"list", undefined>;
+    readonly results: v.ArraySchema<v.ObjectSchema<{
+        readonly object: v.LiteralSchema<"user", undefined>;
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.BrandAction<string, "NotionUserId">]>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly avatar_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"person", undefined>;
+        readonly person: v.ObjectSchema<{
+            readonly email: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+    readonly next_cursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly has_more: v.BooleanSchema<undefined>;
+    readonly type: v.LiteralSchema<"user", undefined>;
+    readonly user: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+}, undefined>;
+export type NotionUserList = v.InferOutput<typeof notionUserListSchema>;

package/dist/protocol/users/user.js

@@ -0,0 +1,20 @@
+import * as v from "valibot";
+export const notionUserIdSchema = v.pipe(v.string(), v.brand("NotionUserId"));
+export const notionUserSchema = v.object({
+    object: v.literal("user"),
+    id: notionUserIdSchema,
+    name: v.optional(v.string()),
+    avatar_url: v.nullable(v.string()),
+    type: v.literal("person"),
+    person: v.object({
+        email: v.string(),
+    }),
+});
+export const notionUserListSchema = v.object({
+    object: v.literal("list"),
+    results: v.array(notionUserSchema),
+    next_cursor: v.nullable(v.string()),
+    has_more: v.boolean(),
+    type: v.literal("user"),
+    user: v.record(v.string(), v.unknown()),
+});

package/dist/queries/querySubscriptions.d.ts

@@ -0,0 +1,17 @@
+import type { NotionDataSourceId } from "../protocol/ids.js";
+import type { QueryDataSourceMessage } from "../protocol/messages/queryDataSource.js";
+export type QueryRefresh = {
+    message: QueryDataSourceMessage;
+    token: QuerySubscriptionToken;
+};
+export type QuerySubscriptionToken = {
+    readonly _tag: "QuerySubscriptionToken";
+};
+export declare class QuerySubscriptions {
+    private readonly bySubscriptionId;
+    track(message: QueryDataSourceMessage): QuerySubscriptionToken;
+    isCurrent(subscriptionId: string, token: QuerySubscriptionToken): boolean;
+    refresh(dataSourceId: NotionDataSourceId): QueryRefresh[];
+    clear(): void;
+}
+//# sourceMappingURL=querySubscriptions.d.ts.map

package/dist/queries/querySubscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"querySubscriptions.d.ts","sourceRoot":"","sources":["../../src/queries/querySubscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AACjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8DAA8D,CAAA;AAE1G,MAAM,MAAM,YAAY,GAAG;IAC1B,OAAO,EAAE,sBAAsB,CAAA;IAC/B,KAAK,EAAE,sBAAsB,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACpC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAA;CACvC,CAAA;AAOD,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4C;IAE7E,KAAK,CAAC,OAAO,EAAE,sBAAsB,GAAG,sBAAsB;IAW9D,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO;IAIzE,OAAO,CAAC,YAAY,EAAE,kBAAkB,GAAG,YAAY,EAAE;IAkBzD,KAAK;CAGL"}

package/dist/queries/querySubscriptions.js

@@ -0,0 +1,38 @@
+export class QuerySubscriptions {
+    constructor() {
+        this.bySubscriptionId = new Map();
+    }
+    track(message) {
+        const token = {
+            _tag: "QuerySubscriptionToken",
+        };
+        this.bySubscriptionId.set(message.subscriptionId, {
+            message,
+            token,
+        });
+        return token;
+    }
+    isCurrent(subscriptionId, token) {
+        return this.bySubscriptionId.get(subscriptionId)?.token === token;
+    }
+    refresh(dataSourceId) {
+        const refreshes = [];
+        for (const queryState of this.bySubscriptionId.values()) {
+            if (queryState.message.dataSourceId !== dataSourceId) {
+                continue;
+            }
+            const token = {
+                _tag: "QuerySubscriptionToken",
+            };
+            queryState.token = token;
+            refreshes.push({
+                message: queryState.message,
+                token,
+            });
+        }
+        return refreshes;
+    }
+    clear() {
+        this.bySubscriptionId.clear();
+    }
+}

package/dist/queries/types.d.ts

@@ -0,0 +1,4 @@
+import type { BridgeMessagePayload } from "../protocol/messagePayload.js";
+import type { CustomBlockQueryDataSourceErrorInfo, QueryDataSourceResultMessage } from "../protocol/messages/queryDataSourceResult.js";
+export type CustomBlockHostQueryDataSourceResult = BridgeMessagePayload<QueryDataSourceResultMessage, CustomBlockQueryDataSourceErrorInfo>;
+//# sourceMappingURL=types.d.ts.map

package/dist/queries/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/queries/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAA;AAC9F,OAAO,KAAK,EACX,mCAAmC,EACnC,4BAA4B,EAC5B,MAAM,oEAAoE,CAAA;AAE3E,MAAM,MAAM,oCAAoC,GAAG,oBAAoB,CACtE,4BAA4B,EAC5B,mCAAmC,CACnC,CAAA"}

package/dist/queries/types.js

@@ -0,0 +1 @@
+export {};

package/dist/queries/validateQueryDataSourceFilter.d.ts

@@ -0,0 +1,5 @@
+import type { NotionCollectionSchema } from "../protocol/dataSources/dataSource.js";
+import type { ResolvedCustomBlockDataSourceFilter } from "../protocol/messages/queryDataSource.js";
+import type { CustomBlockQueryDataSourceErrorInfo } from "../protocol/messages/queryDataSourceResult.js";
+export declare function validateQueryDataSourceFilter(filter: ResolvedCustomBlockDataSourceFilter | undefined, collectionSchema: NotionCollectionSchema | undefined): CustomBlockQueryDataSourceErrorInfo | undefined;
+//# sourceMappingURL=validateQueryDataSourceFilter.d.ts.map

package/dist/queries/validateQueryDataSourceFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateQueryDataSourceFilter.d.ts","sourceRoot":"","sources":["../../src/queries/validateQueryDataSourceFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4DAA4D,CAAA;AACxG,OAAO,KAAK,EAGX,mCAAmC,EAEnC,MAAM,8DAA8D,CAAA;AACrE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,oEAAoE,CAAA;AAO7H,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,mCAAmC,GAAG,SAAS,EACvD,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,GAClD,mCAAmC,GAAG,SAAS,CAajD"}

package/dist/queries/validateQueryDataSourceFilter.js

@@ -0,0 +1,72 @@
+import { unreachable } from "../utils.js";
+export function validateQueryDataSourceFilter(filter, collectionSchema) {
+    if (filter === undefined || collectionSchema === undefined) {
+        return undefined;
+    }
+    const propertyFilters = "and" in filter ? filter.and : [filter];
+    for (const propertyFilter of propertyFilters) {
+        const error = validatePropertyFilter(propertyFilter, collectionSchema);
+        if (error !== undefined) {
+            return error;
+        }
+    }
+    return undefined;
+}
+function validatePropertyFilter(filter, collectionSchema) {
+    const propertySchema = collectionSchema.propertiesById[filter.propertyId];
+    if (propertySchema === undefined) {
+        return undefined;
+    }
+    const optionFilter = getOptionFilter(filter);
+    if (optionFilter === undefined ||
+        propertySchema.type !== optionFilter.propertyType) {
+        return undefined;
+    }
+    const optionNames = new Set(propertySchema.options.map(option => option.name));
+    const invalidOptionName = getOptionFilterValues(optionFilter.operator).find(optionName => !optionNames.has(optionName));
+    if (invalidOptionName === undefined) {
+        return undefined;
+    }
+    return {
+        code: "invalid_data_source_query_filter",
+        message: `Data source query filter option "${invalidOptionName}" is not defined for property "${filter.propertyId}".`,
+        isRetryable: false,
+    };
+}
+function getOptionFilter(filter) {
+    if ("select" in filter) {
+        return { propertyType: "select", operator: filter.select };
+    }
+    if ("multi_select" in filter) {
+        return { propertyType: "multi_select", operator: filter.multi_select };
+    }
+    if ("status" in filter) {
+        return { propertyType: "status", operator: filter.status };
+    }
+    return undefined;
+}
+function getOptionFilterValues(operator) {
+    let value;
+    if ("equals" in operator) {
+        value = operator.equals;
+    }
+    else if ("does_not_equal" in operator) {
+        value = operator.does_not_equal;
+    }
+    else if ("contains" in operator) {
+        value = operator.contains;
+    }
+    else if ("contains_all" in operator) {
+        value = operator.contains_all;
+    }
+    else if ("does_not_contain" in operator) {
+        value = operator.does_not_contain;
+    }
+    else if ("is_empty" in operator || "is_not_empty" in operator) {
+        return [];
+    }
+    else {
+        return unreachable(operator);
+    }
+    return Array.isArray(value) ? value : [value];
+}

package/dist/queries/validateQueryDataSourceSorts.d.ts

@@ -0,0 +1,8 @@
+import type { NotionCollectionSchema } from "../protocol/dataSources/dataSource.js";
+import { type ResolvedCustomBlockDataSourceSort } from "../protocol/messages/queryDataSource.js";
+import type { CustomBlockQueryDataSourceErrorInfo } from "../protocol/messages/queryDataSourceResult.js";
+/**
+ * Ensures the sorts of a data source query are valid.
+ */
+export declare function validateQueryDataSourceSorts(sorts: ResolvedCustomBlockDataSourceSort[] | undefined, collectionSchema: NotionCollectionSchema | undefined): CustomBlockQueryDataSourceErrorInfo | undefined;
+//# sourceMappingURL=validateQueryDataSourceSorts.d.ts.map

package/dist/queries/validateQueryDataSourceSorts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateQueryDataSourceSorts.d.ts","sourceRoot":"","sources":["../../src/queries/validateQueryDataSourceSorts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4DAA4D,CAAA;AAExG,OAAO,EAEN,KAAK,iCAAiC,EACtC,MAAM,8DAA8D,CAAA;AACrE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,oEAAoE,CAAA;AAM7H;;GAEG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,iCAAiC,EAAE,GAAG,SAAS,EACtD,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,GAClD,mCAAmC,GAAG,SAAS,CAkDjD"}

package/dist/queries/validateQueryDataSourceSorts.js

@@ -0,0 +1,47 @@
+import { CUSTOM_BLOCK_DATA_SOURCE_SORTABLE_PROPERTY_TYPES } from "../protocol/dataSources/propertySchema.js";
+import { CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS, } from "../protocol/messages/queryDataSource.js";
+const supportedDataSourceSortPropertyTypes = new Set(CUSTOM_BLOCK_DATA_SOURCE_SORTABLE_PROPERTY_TYPES);
+/**
+ * Ensures the sorts of a data source query are valid.
+ */
+export function validateQueryDataSourceSorts(sorts, collectionSchema) {
+    if (sorts === undefined) {
+        return undefined;
+    }
+    if (sorts.length > CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS) {
+        return {
+            code: "invalid_data_source_query_sort",
+            message: `Data source query sorts may contain at most ${CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS} entries.`,
+            isRetryable: false,
+        };
+    }
+    const seenPropertyIds = new Set();
+    for (const sort of sorts) {
+        if (seenPropertyIds.has(sort.propertyId)) {
+            return {
+                code: "invalid_data_source_query_sort",
+                message: `Data source query sorts cannot contain duplicate property ID "${sort.propertyId}".`,
+                isRetryable: false,
+            };
+        }
+        seenPropertyIds.add(sort.propertyId);
+        if (collectionSchema !== undefined &&
+            !Object.prototype.hasOwnProperty.call(collectionSchema.propertiesById, sort.propertyId)) {
+            return {
+                code: "invalid_data_source_query_sort",
+                message: `Data source query sort property ID "${sort.propertyId}" is not defined in the bound data source schema.`,
+                isRetryable: false,
+            };
+        }
+        const propertySchema = collectionSchema?.propertiesById[sort.propertyId];
+        if (propertySchema !== undefined &&
+            !supportedDataSourceSortPropertyTypes.has(propertySchema.type)) {
+            return {
+                code: "invalid_data_source_query_sort",
+                message: `Data source query sorts do not yet support property type "${propertySchema.type}".`,
+                isRetryable: false,
+            };
+        }
+    }
+    return undefined;
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Throws when a discriminated union has an unexpected member.
+ */
+export declare function unreachable(value: never): never;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAI/C"}

package/dist/utils.js

@@ -0,0 +1,6 @@
+/**
+ * Throws when a discriminated union has an unexpected member.
+ */
+export function unreachable(value) {
+    throw new Error(`[custom-blocks-host] Unexpected value encountered: ${JSON.stringify(value)}`);
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@notionhq/custom-blocks-host",
+	"version": "0.0.1",
+	"description": "Reusable host runtime for Notion custom blocks.",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"dependencies": {
+		"valibot": "^1.3.1"
+	},
+	"files": [
+		"src",
+		"dist",
+		"README.md"
+	]
+}

package/src/autoBindProperties.ts

@@ -0,0 +1,63 @@
+import type { NotionPropertyType } from "@notionhq/custom-blocks-protocol/dataSources/propertySchema.js"
+
+export type AutoBindableProperty = {
+	name: string
+	type: NotionPropertyType
+}
+
+/**
+ * Finds property IDs for a manifest's properties without changing the
+ * manifest's semantic keys.
+ *
+ * For each manifest property:
+ * 1. Consider only schema properties of the same type.
+ * 2. A schema property is a candidate if its ID equals the manifest key
+ *    (exact string: no trim, no case folding) or its display name equals
+ *    the manifest display name after `trim()` and lowercasing.
+ * 3. Bind when there is exactly one candidate. Otherwise leave it unmapped.
+ */
+export function getAutoBoundPropertyIdsByKey(args: {
+	manifestProperties: Readonly<Record<string, AutoBindableProperty>>
+	propertySchemasById: Readonly<Record<string, AutoBindableProperty>>
+}): Record<string, string> {
+	const { manifestProperties, propertySchemasById } = args
+	const mappings: Array<[string, string]> = []
+
+	for (const [propertyKey, manifestProperty] of Object.entries(
+		manifestProperties,
+	)) {
+		const propertyId = getAutoBoundPropertyId({
+			propertyKey,
+			manifestProperty,
+			propertySchemasById,
+		})
+		if (propertyId !== undefined) {
+			mappings.push([propertyKey, propertyId])
+		}
+	}
+
+	return Object.fromEntries(mappings)
+}
+
+function getAutoBoundPropertyId(args: {
+	propertyKey: string
+	manifestProperty: AutoBindableProperty
+	propertySchemasById: Readonly<Record<string, AutoBindableProperty>>
+}): string | undefined {
+	const { propertyKey, manifestProperty, propertySchemasById } = args
+	const normalizedManifestName = normalizePropertyDisplayName(
+		manifestProperty.name,
+	)
+	const candidates = Object.entries(propertySchemasById).filter(
+		([schemaId, propertySchema]) =>
+			propertySchema.type === manifestProperty.type &&
+			(schemaId === propertyKey ||
+				normalizePropertyDisplayName(propertySchema.name) ===
+					normalizedManifestName),
+	)
+	return candidates.length === 1 ? candidates[0][0] : undefined
+}
+
+function normalizePropertyDisplayName(value: string): string {
+	return value.trim().toLowerCase()
+}