@keystrokehq/notion 0.0.1

package/dist/search.mjs

@@ -0,0 +1,44 @@
+import { createNotionClient, withRateLimitRetry } from "./client.mjs";
+import { normalizeListMeta, normalizeSearchResult, notionListResponseSchema, notionSearchResultSchema } from "./schemas.mjs";
+import { t as notionOperation } from "./factory-BttZ5eEq.mjs";
+import { z } from "zod";
+
+//#region src/search.ts
+const searchWorkspace = notionOperation({
+	id: "search_notion_workspace",
+	name: "Search Notion Workspace",
+	description: "Search shared Notion pages or data sources by title",
+	input: z.object({
+		query: z.string().optional(),
+		object: z.enum(["page", "data_source"]).optional(),
+		sortDirection: z.enum(["ascending", "descending"]).optional(),
+		startCursor: z.string().optional(),
+		pageSize: z.number().int().positive().max(100).optional()
+	}),
+	output: notionListResponseSchema(notionSearchResultSchema),
+	run: async (input, credentials) => {
+		const client = createNotionClient(credentials);
+		const response = await withRateLimitRetry(() => client.search({
+			...input.query ? { query: input.query } : {},
+			...input.object ? { filter: {
+				property: "object",
+				value: input.object
+			} } : {},
+			sort: {
+				timestamp: "last_edited_time",
+				direction: input.sortDirection ?? "descending"
+			},
+			...input.startCursor ? { start_cursor: input.startCursor } : {},
+			...input.pageSize !== void 0 ? { page_size: input.pageSize } : {}
+		}));
+		const meta = normalizeListMeta(response);
+		return {
+			results: response.results.map(normalizeSearchResult),
+			hasMore: meta.hasMore,
+			nextCursor: meta.nextCursor
+		};
+	}
+});
+
+//#endregion
+export { searchWorkspace };

package/dist/shared-C6A6JPl3.mjs

@@ -0,0 +1,43 @@
+//#region src/shared.ts
+function buildPageParent(parent) {
+	if (parent.dataSourceId) return {
+		type: "data_source_id",
+		data_source_id: parent.dataSourceId
+	};
+	if (parent.databaseId) return {
+		type: "database_id",
+		database_id: parent.databaseId
+	};
+	if (parent.pageId) return {
+		type: "page_id",
+		page_id: parent.pageId
+	};
+	throw new Error("Provide one of pageId, databaseId, or dataSourceId.");
+}
+function buildCommentTarget(input) {
+	if (input.discussionId) return { discussion_id: input.discussionId };
+	if (input.blockId) return { parent: {
+		type: "block_id",
+		block_id: input.blockId
+	} };
+	if (input.pageId) return { parent: {
+		type: "page_id",
+		page_id: input.pageId
+	} };
+	throw new Error("Provide one of pageId, blockId, or discussionId.");
+}
+function buildPlainTextRichText(content) {
+	return [{
+		type: "text",
+		text: { content }
+	}];
+}
+function buildPaginationInput(limit, startCursor) {
+	return {
+		...limit !== void 0 ? { page_size: limit } : {},
+		...startCursor ? { start_cursor: startCursor } : {}
+	};
+}
+
+//#endregion
+export { buildPlainTextRichText as i, buildPageParent as n, buildPaginationInput as r, buildCommentTarget as t };

package/dist/triggers.d.mts

@@ -0,0 +1,72 @@
+import { n as notion } from "./integration-C7pL009K.mjs";
+import { a as notionWebhookCredentialSet } from "./provider-app-DehoD5sd.mjs";
+import { NotionWebhookEvent, NotionWebhookPayload } from "./events.mjs";
+import { z } from "zod";
+import { BoundTrigger, WebhookRequest } from "@keystrokehq/core";
+import { IntegrationTriggerBindingFactory, IntegrationTriggerBindingOptions } from "@keystrokehq/integration-authoring";
+import { PollingTriggerManifest, WebhookTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers.d.ts
+declare const notionPollingBatchSchema: z.ZodObject<{
+  results: z.ZodArray<z.ZodObject<{
+    eventId: z.ZodString;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    entityId: z.ZodString;
+    entityType: z.ZodString;
+    source: z.ZodLiteral<"polling">;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  hasMore: z.ZodBoolean;
+  nextCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type NotionPollingBatch = z.output<typeof notionPollingBatchSchema>;
+type NotionWebhookCredentialSets = readonly [typeof notion, typeof notionWebhookCredentialSet];
+type NotionPollingCredentialSets = readonly [typeof notion];
+type NotionWebhookBinding = IntegrationTriggerBindingFactory<NotionWebhookEvent, NotionWebhookCredentialSets, WebhookTriggerManifest, NotionWebhookPayload, WebhookRequest>;
+type NotionPollingBoundTrigger<TOutput> = BoundTrigger<NotionPollingBatch, NotionPollingCredentialSets, PollingTriggerManifest, TOutput>;
+type NotionPollingBindingOptions<TOutput = NotionPollingBatch> = IntegrationTriggerBindingOptions<NotionPollingBatch, TOutput> & {
+  readonly schedule?: string;
+};
+type NotionPollingAllPagesOptions<TOutput = NotionPollingBatch> = NotionPollingBindingOptions<TOutput> & {
+  readonly query?: string;
+};
+type NotionPollingCommentsOptions<TOutput = NotionPollingBatch> = NotionPollingBindingOptions<TOutput> & {
+  readonly blockId: string;
+};
+type NotionPollingDataSourceOptions<TOutput = NotionPollingBatch> = NotionPollingBindingOptions<TOutput> & {
+  readonly dataSourceId: string;
+};
+type NotionPollingPageOptions<TOutput = NotionPollingBatch> = NotionPollingBindingOptions<TOutput> & {
+  readonly pageId: string;
+};
+type NotionWebhookNamespace = Readonly<{
+  pageCreated: NotionWebhookBinding;
+  pageContentUpdated: NotionWebhookBinding;
+  pagePropertiesUpdated: NotionWebhookBinding;
+  pageMoved: NotionWebhookBinding;
+  pageDeleted: NotionWebhookBinding;
+  pageUndeleted: NotionWebhookBinding;
+  pageLocked: NotionWebhookBinding;
+  pageUnlocked: NotionWebhookBinding;
+  commentCreated: NotionWebhookBinding;
+  commentUpdated: NotionWebhookBinding;
+  commentDeleted: NotionWebhookBinding;
+  dataSourceCreated: NotionWebhookBinding;
+  dataSourceContentUpdated: NotionWebhookBinding;
+  dataSourceSchemaUpdated: NotionWebhookBinding;
+  dataSourceMoved: NotionWebhookBinding;
+  dataSourceDeleted: NotionWebhookBinding;
+  dataSourceUndeleted: NotionWebhookBinding;
+}>;
+declare const webhooks: NotionWebhookNamespace;
+type NotionPollingNamespace = Readonly<{
+  allPageEvents: (options: NotionPollingAllPagesOptions<unknown>) => NotionPollingBoundTrigger<unknown>;
+  commentsAdded: (options: NotionPollingCommentsOptions<unknown>) => NotionPollingBoundTrigger<unknown>;
+  pageAddedToDataSource: (options: NotionPollingDataSourceOptions<unknown>) => NotionPollingBoundTrigger<unknown>;
+  pageAddedToPage: (options: NotionPollingPageOptions<unknown>) => NotionPollingBoundTrigger<unknown>;
+  pageUpdated: (options: NotionPollingPageOptions<unknown>) => NotionPollingBoundTrigger<unknown>;
+}>;
+declare const polling: NotionPollingNamespace;
+//#endregion
+export { NotionPollingNamespace, NotionWebhookNamespace, polling, webhooks };

package/dist/triggers.mjs

@@ -0,0 +1,285 @@
+import { o as notionWebhookCredentialSet, t as notion } from "./integration-Hfdp-q_v.mjs";
+import { createNotionClient, withRateLimitRetry } from "./client.mjs";
+import { createPollingEvent, normalizeWebhookEvent, notionPollingEventSchema, notionWebhookPayloadSchema } from "./events.mjs";
+import { verifyNotionWebhook } from "./verification.mjs";
+import { z } from "zod";
+import { createPollingTriggerBindingFactory, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+const DEFAULT_POLLING_SCHEDULE = "*/10 * * * *";
+const notionPollingBatchSchema = z.object({
+	results: z.array(notionPollingEventSchema),
+	hasMore: z.boolean(),
+	nextCursor: z.string().nullish()
+});
+const notionWebhookCredentialSets = [notion, notionWebhookCredentialSet];
+const notionPollingCredentialSets = [notion];
+function resolveSchedule(schedule) {
+	return schedule ?? DEFAULT_POLLING_SCHEDULE;
+}
+function isAfterLastPolled(lastPolledAt, occurredAt) {
+	if (!occurredAt) return false;
+	if (!lastPolledAt) return true;
+	return occurredAt > lastPolledAt;
+}
+function createWebhookBinding(config) {
+	return createWebhookTriggerBindingFactory({
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		path: "/notion",
+		method: "POST",
+		payload: notionWebhookPayloadSchema,
+		credentialSets: notionWebhookCredentialSets,
+		verify: (request, ctx) => {
+			const webhookCredentials = ctx.credentials["notion-webhook"];
+			if (!verifyNotionWebhook({
+				headers: request.headers,
+				body: request.rawBody
+			}, webhookCredentials.verificationToken)) throw new Error("Invalid Notion webhook signature.");
+		},
+		definitionFilter: (payload) => payload.type === config.eventType,
+		mapPayload: (payload) => payload.type === config.eventType ? normalizeWebhookEvent(payload) : null,
+		idempotencyKey: (payload) => payload.id,
+		response: { successStatus: 200 }
+	});
+}
+function createPollingBinding(config) {
+	return (options) => createPollingTriggerBindingFactory({
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		schedule: resolveSchedule(options.schedule),
+		credentialSets: notionPollingCredentialSets,
+		response: notionPollingBatchSchema,
+		poll: (ctx) => config.build(options, {
+			credentials: { notion: ctx.credentials.notion },
+			lastPolledAt: ctx.lastPolledAt
+		}),
+		definitionFilter: (payload) => payload.results.length > 0,
+		idempotencyKey: (payload) => payload.results[0]?.eventId
+	})({
+		name: options.name,
+		description: options.description,
+		filter: options.filter,
+		transform: options.transform
+	});
+}
+async function pollAllPages(credentials, lastPolledAt, query) {
+	const client = createNotionClient(credentials);
+	return {
+		results: (await withRateLimitRetry(() => client.search({
+			...query ? { query } : {},
+			filter: {
+				property: "object",
+				value: "page"
+			},
+			sort: {
+				timestamp: "last_edited_time",
+				direction: "descending"
+			},
+			page_size: 100
+		}))).results.filter((result) => result.object === "page").filter((result) => isAfterLastPolled(lastPolledAt, "last_edited_time" in result ? result.last_edited_time : null)).map((result) => createPollingEvent({
+			eventId: `page:${result.id}:${"last_edited_time" in result ? result.last_edited_time : "unknown"}`,
+			eventType: "page.discovered",
+			occurredAt: "last_edited_time" in result ? result.last_edited_time : (/* @__PURE__ */ new Date()).toISOString(),
+			entityId: result.id,
+			entityType: "page",
+			data: { url: "url" in result ? result.url : void 0 }
+		})),
+		hasMore: false,
+		nextCursor: null
+	};
+}
+async function pollCommentsAdded(credentials, lastPolledAt, blockId) {
+	const client = createNotionClient(credentials);
+	return {
+		results: (await withRateLimitRetry(() => client.comments.list({
+			block_id: blockId,
+			page_size: 100
+		}))).results.filter((comment) => isAfterLastPolled(lastPolledAt, comment.created_time)).map((comment) => createPollingEvent({
+			eventId: `comment:${comment.id}:${comment.created_time}`,
+			eventType: "comment.created",
+			occurredAt: comment.created_time,
+			entityId: comment.id,
+			entityType: "comment",
+			data: {
+				blockId,
+				discussionId: comment.discussion_id
+			}
+		})),
+		hasMore: false,
+		nextCursor: null
+	};
+}
+async function pollPagesAddedToDataSource(credentials, lastPolledAt, dataSourceId) {
+	const client = createNotionClient(credentials);
+	return {
+		results: (await withRateLimitRetry(() => client.dataSources.query({
+			data_source_id: dataSourceId,
+			page_size: 100,
+			sorts: [{
+				timestamp: "created_time",
+				direction: "descending"
+			}]
+		}))).results.filter((page) => "object" in page && page.object === "page" && "created_time" in page).filter((page) => isAfterLastPolled(lastPolledAt, page.created_time)).map((page) => createPollingEvent({
+			eventId: `data-source-page:${page.id}:${page.created_time}`,
+			eventType: "page.added_to_data_source",
+			occurredAt: page.created_time,
+			entityId: page.id,
+			entityType: "page",
+			data: { dataSourceId }
+		})),
+		hasMore: false,
+		nextCursor: null
+	};
+}
+async function pollPagesAddedToPage(credentials, lastPolledAt, pageId) {
+	const client = createNotionClient(credentials);
+	return {
+		results: (await withRateLimitRetry(() => client.blocks.children.list({
+			block_id: pageId,
+			page_size: 100
+		}))).results.filter((block) => "type" in block && block.type === "child_page" && "created_time" in block).filter((block) => isAfterLastPolled(lastPolledAt, block.created_time)).map((block) => createPollingEvent({
+			eventId: `child-page:${block.id}:${block.created_time}`,
+			eventType: "page.added_to_page",
+			occurredAt: block.created_time,
+			entityId: block.id,
+			entityType: "page",
+			data: { pageId }
+		})),
+		hasMore: false,
+		nextCursor: null
+	};
+}
+async function pollPageUpdated(credentials, lastPolledAt, pageId) {
+	const client = createNotionClient(credentials);
+	const response = await withRateLimitRetry(() => client.pages.retrieve({ page_id: pageId }));
+	return {
+		results: "last_edited_time" in response && isAfterLastPolled(lastPolledAt, response.last_edited_time) ? [createPollingEvent({
+			eventId: `page-updated:${response.id}:${response.last_edited_time}`,
+			eventType: "page.updated",
+			occurredAt: response.last_edited_time,
+			entityId: response.id,
+			entityType: "page",
+			data: { url: "url" in response ? response.url : void 0 }
+		})] : [],
+		hasMore: false,
+		nextCursor: null
+	};
+}
+const webhooks = Object.freeze({
+	pageCreated: createWebhookBinding({
+		defaultName: "Notion Page Created",
+		defaultDescription: "Fires when Notion creates a page",
+		eventType: "page.created"
+	}),
+	pageContentUpdated: createWebhookBinding({
+		defaultName: "Notion Page Content Updated",
+		defaultDescription: "Fires when Notion updates page content",
+		eventType: "page.content_updated"
+	}),
+	pagePropertiesUpdated: createWebhookBinding({
+		defaultName: "Notion Page Properties Updated",
+		defaultDescription: "Fires when Notion updates page properties",
+		eventType: "page.properties_updated"
+	}),
+	pageMoved: createWebhookBinding({
+		defaultName: "Notion Page Moved",
+		defaultDescription: "Fires when a Notion page moves",
+		eventType: "page.moved"
+	}),
+	pageDeleted: createWebhookBinding({
+		defaultName: "Notion Page Deleted",
+		defaultDescription: "Fires when Notion deletes a page",
+		eventType: "page.deleted"
+	}),
+	pageUndeleted: createWebhookBinding({
+		defaultName: "Notion Page Restored",
+		defaultDescription: "Fires when Notion restores a page from trash",
+		eventType: "page.undeleted"
+	}),
+	pageLocked: createWebhookBinding({
+		defaultName: "Notion Page Locked",
+		defaultDescription: "Fires when Notion locks a page",
+		eventType: "page.locked"
+	}),
+	pageUnlocked: createWebhookBinding({
+		defaultName: "Notion Page Unlocked",
+		defaultDescription: "Fires when Notion unlocks a page",
+		eventType: "page.unlocked"
+	}),
+	commentCreated: createWebhookBinding({
+		defaultName: "Notion Comment Created",
+		defaultDescription: "Fires when Notion creates a comment",
+		eventType: "comment.created"
+	}),
+	commentUpdated: createWebhookBinding({
+		defaultName: "Notion Comment Updated",
+		defaultDescription: "Fires when Notion updates a comment",
+		eventType: "comment.updated"
+	}),
+	commentDeleted: createWebhookBinding({
+		defaultName: "Notion Comment Deleted",
+		defaultDescription: "Fires when Notion deletes a comment",
+		eventType: "comment.deleted"
+	}),
+	dataSourceCreated: createWebhookBinding({
+		defaultName: "Notion Data Source Created",
+		defaultDescription: "Fires when Notion creates a data source",
+		eventType: "data_source.created"
+	}),
+	dataSourceContentUpdated: createWebhookBinding({
+		defaultName: "Notion Data Source Content Updated",
+		defaultDescription: "Fires when Notion updates data-source content",
+		eventType: "data_source.content_updated"
+	}),
+	dataSourceSchemaUpdated: createWebhookBinding({
+		defaultName: "Notion Data Source Schema Updated",
+		defaultDescription: "Fires when Notion updates data-source schema",
+		eventType: "data_source.schema_updated"
+	}),
+	dataSourceMoved: createWebhookBinding({
+		defaultName: "Notion Data Source Moved",
+		defaultDescription: "Fires when Notion moves a data source",
+		eventType: "data_source.moved"
+	}),
+	dataSourceDeleted: createWebhookBinding({
+		defaultName: "Notion Data Source Deleted",
+		defaultDescription: "Fires when Notion deletes a data source",
+		eventType: "data_source.deleted"
+	}),
+	dataSourceUndeleted: createWebhookBinding({
+		defaultName: "Notion Data Source Restored",
+		defaultDescription: "Fires when Notion restores a data source",
+		eventType: "data_source.undeleted"
+	})
+});
+const polling = Object.freeze({
+	allPageEvents: createPollingBinding({
+		defaultName: "Notion All Page Events",
+		defaultDescription: "Poll for recently changed Notion pages",
+		build: (options, ctx) => pollAllPages(ctx.credentials.notion, ctx.lastPolledAt, options.query)
+	}),
+	commentsAdded: createPollingBinding({
+		defaultName: "Notion Comments Added",
+		defaultDescription: "Poll for newly created Notion comments on a block or page",
+		build: (options, ctx) => pollCommentsAdded(ctx.credentials.notion, ctx.lastPolledAt, options.blockId)
+	}),
+	pageAddedToDataSource: createPollingBinding({
+		defaultName: "Notion Page Added To Data Source",
+		defaultDescription: "Poll for newly created entries in a Notion data source",
+		build: (options, ctx) => pollPagesAddedToDataSource(ctx.credentials.notion, ctx.lastPolledAt, options.dataSourceId)
+	}),
+	pageAddedToPage: createPollingBinding({
+		defaultName: "Notion Page Added To Page",
+		defaultDescription: "Poll for new child pages added under a Notion page",
+		build: (options, ctx) => pollPagesAddedToPage(ctx.credentials.notion, ctx.lastPolledAt, options.pageId)
+	}),
+	pageUpdated: createPollingBinding({
+		defaultName: "Notion Page Updated",
+		defaultDescription: "Poll a single Notion page for updates",
+		build: (options, ctx) => pollPageUpdated(ctx.credentials.notion, ctx.lastPolledAt, options.pageId)
+	})
+});
+
+//#endregion
+export { polling, webhooks };

package/dist/users.d.mts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/users.d.ts
+declare const getMe: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  object: z.ZodLiteral<"user">;
+  type: z.ZodString;
+  name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"notion", z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getUser: _keystrokehq_core0.Operation<z.ZodObject<{
+  userId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  object: z.ZodLiteral<"user">;
+  type: z.ZodString;
+  name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"notion", z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const listUsers: _keystrokehq_core0.Operation<z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+  startCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  results: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"user">;
+    type: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, z.core.$strip>>;
+  hasMore: z.ZodBoolean;
+  nextCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"notion", z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  NOTION_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getMe, getUser, listUsers };

package/dist/users.mjs

@@ -0,0 +1,52 @@
+import { createNotionClient, withRateLimitRetry } from "./client.mjs";
+import { normalizeListMeta, normalizeUser, notionListResponseSchema, notionUserSchema } from "./schemas.mjs";
+import { t as notionOperation } from "./factory-BttZ5eEq.mjs";
+import { r as buildPaginationInput } from "./shared-C6A6JPl3.mjs";
+import { z } from "zod";
+
+//#region src/users.ts
+const getMe = notionOperation({
+	id: "get_notion_me",
+	name: "Get Notion Bot User",
+	description: "Retrieve the bot user associated with the current Notion token",
+	input: z.object({}),
+	output: notionUserSchema,
+	run: async (_input, credentials) => {
+		const client = createNotionClient(credentials);
+		return normalizeUser(await withRateLimitRetry(() => client.users.me({})));
+	}
+});
+const getUser = notionOperation({
+	id: "get_notion_user",
+	name: "Get Notion User",
+	description: "Retrieve a Notion user by ID",
+	input: z.object({ userId: z.string().min(1) }),
+	output: notionUserSchema,
+	run: async (input, credentials) => {
+		const client = createNotionClient(credentials);
+		return normalizeUser(await withRateLimitRetry(() => client.users.retrieve({ user_id: input.userId })));
+	}
+});
+const listUsers = notionOperation({
+	id: "list_notion_users",
+	name: "List Notion Users",
+	description: "List users visible to the current Notion integration",
+	input: z.object({
+		limit: z.number().int().positive().max(100).optional(),
+		startCursor: z.string().optional()
+	}),
+	output: notionListResponseSchema(notionUserSchema),
+	run: async (input, credentials) => {
+		const client = createNotionClient(credentials);
+		const response = await withRateLimitRetry(() => client.users.list(buildPaginationInput(input.limit, input.startCursor)));
+		const meta = normalizeListMeta(response);
+		return {
+			results: response.results.map(normalizeUser),
+			hasMore: meta.hasMore,
+			nextCursor: meta.nextCursor
+		};
+	}
+});
+
+//#endregion
+export { getMe, getUser, listUsers };

package/dist/verification.d.mts

@@ -0,0 +1,18 @@
+//#region src/verification.d.ts
+/**
+ * notion/verification.ts
+ *
+ * Notion webhook signature verification.
+ *
+ * Notion signs webhook requests using HMAC-SHA256 with the verification token.
+ * Delegates the HMAC plumbing to the shared `verifyHmacWebhook` helper.
+ *
+ * Header: `x-notion-signature`: `sha256=<hex-digest>`
+ * Signature: `HMAC-SHA256(verificationToken, <raw body>)`
+ */
+declare function verifyNotionWebhook(request: {
+  headers: Record<string, string | string[] | undefined>;
+  body: string | Buffer;
+}, verificationToken: string): boolean;
+//#endregion
+export { verifyNotionWebhook };

package/dist/verification.mjs

@@ -0,0 +1,24 @@
+import { verifyHmacWebhook } from "@keystrokehq/integration-authoring/webhooks";
+
+//#region src/verification.ts
+/**
+* notion/verification.ts
+*
+* Notion webhook signature verification.
+*
+* Notion signs webhook requests using HMAC-SHA256 with the verification token.
+* Delegates the HMAC plumbing to the shared `verifyHmacWebhook` helper.
+*
+* Header: `x-notion-signature`: `sha256=<hex-digest>`
+* Signature: `HMAC-SHA256(verificationToken, <raw body>)`
+*/
+function verifyNotionWebhook(request, verificationToken) {
+	return verifyHmacWebhook(request, {
+		secret: verificationToken,
+		signatureHeader: "x-notion-signature",
+		signaturePrefix: "sha256="
+	});
+}
+
+//#endregion
+export { verifyNotionWebhook };