@notionhq/apps 0.0.33 → 0.0.35

package/src/configured-events.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import { events } from "./events.generated.js";
+import { database } from "./notion-as-code/database.js";
+import { finishMetadataRecording, startMetadataRecording } from "./notion-as-code/recorder.js";
+import type { DataSourceHandle } from "./notion-as-code/database.js";
+
+function tasks() {
+	const recorder = startMetadataRecording();
+	const handle = database("tasks-db", {
+		dataSourceResourceId: "tasks",
+		name: "Tasks",
+		schema: {
+			Name: { resourceId: "name", type: "title" },
+			Status: { resourceId: "status", type: "select", options: [] },
+		},
+	});
+	finishMetadataRecording(recorder);
+	return handle.dataSource;
+}
+
+describe("configured Apps events", () => {
+	it("serializes property handles without including declaration objects", () => {
+		const dataSource = tasks();
+		expectTypeOf(dataSource.properties.Status.resourceId).toEqualTypeOf<"status">();
+		expectTypeOf(dataSource.properties.Status.propertyType).toEqualTypeOf<"select">();
+		expect(
+			events.notionPageUpdated({ dataSource, properties: [dataSource.properties.Status] }),
+		).toEqual({
+			type: "notion.page.updated",
+			dataSourceResourceId: "tasks",
+			propertyResourceIds: ["status"],
+			includePageContent: false,
+		});
+	});
+	it("serializes a page-created data source", () => {
+		expect(events.notionPageCreated({ dataSource: tasks() })).toEqual({
+			type: "notion.page.created",
+			dataSourceResourceId: "tasks",
+		});
+	});
+	it("supports page-content-only watches", () => {
+		expect(events.notionPageUpdated({ dataSource: tasks(), includePageContent: true })).toEqual(
+			{
+				type: "notion.page.updated",
+				dataSourceResourceId: "tasks",
+				includePageContent: true,
+			},
+		);
+	});
+	it("checks property ownership even when source types have been widened", () => {
+		const original = tasks();
+		const dataSource: DataSourceHandle = original;
+		const status = original.properties.Status;
+		if (!status) throw new Error("Missing Status property");
+		const property = { ...status, dataSourceResourceId: "other-source" };
+		expect(() => events.notionPageUpdated({ dataSource, properties: [property] })).toThrow(
+			"does not belong",
+		);
+	});
+	it("serializes weekly schedule details", () => {
+		expect(
+			events.scheduled({
+				frequency: "week",
+				interval: 1,
+				weekdays: { MO: true, FR: true },
+				start: "2026-09-23T09:00:00",
+				timeZone: "America/Los_Angeles",
+			}),
+		).toEqual({
+			type: "recurrence",
+			frequency: "week",
+			interval: 1,
+			weekdays: { MO: true, FR: true },
+			start: "2026-09-23T09:00:00",
+			timeZone: "America/Los_Angeles",
+		});
+	});
+	it("retains unconfigured events for setup in Notion", () => {
+		expect([
+			events.scheduled(),
+			events.notionPageCreated(),
+			events.notionPageUpdated(),
+		]).toEqual([
+			{ type: "recurrence" },
+			{ type: "notion.page.created" },
+			{ type: "notion.page.updated" },
+		]);
+	});
+});

package/src/configured-events.ts

@@ -0,0 +1,101 @@
+import type { DataSourceHandle, PropertyHandle } from "./notion-as-code/database.js";
+import type { NotionAsCodeSchema } from "./notion-as-code/intents.js";
+import type { RecurrenceSchedule } from "./notion-as-code/recurrence.js";
+
+export type RecurrenceTrigger = { type: "recurrence" } & (
+	| RecurrenceSchedule
+	| { frequency?: never }
+);
+export type NotionPageCreatedTrigger = {
+	type: "notion.page.created";
+	dataSourceResourceId?: string;
+};
+export type NotionPageUpdatedTrigger = {
+	type: "notion.page.updated";
+	dataSourceResourceId?: string;
+	propertyResourceIds?: string[];
+	includePageContent?: boolean;
+};
+
+type WatchablePropertyType =
+	| "title"
+	| "text"
+	| "number"
+	| "select"
+	| "multi_select"
+	| "status"
+	| "date"
+	| "person"
+	| "checkbox"
+	| "url"
+	| "email"
+	| "phone_number"
+	| "relation";
+
+type WatchableProperty<Property extends NotionAsCodeSchema[string]> = Property extends {
+	type: WatchablePropertyType;
+}
+	? PropertyHandle<Property>
+	: never;
+
+type SourceProperty<Schema extends NotionAsCodeSchema> = WatchableProperty<Schema[keyof Schema]>;
+export type PageUpdatedOptions<Schema extends NotionAsCodeSchema> = {
+	dataSource: DataSourceHandle<Schema>;
+} & (
+	| {
+			properties: readonly [
+				SourceProperty<NoInfer<Schema>>,
+				...SourceProperty<NoInfer<Schema>>[],
+			];
+			includePageContent?: boolean;
+	  }
+	| { properties?: readonly SourceProperty<NoInfer<Schema>>[]; includePageContent: true }
+);
+
+/** Configure a recurrence, or omit options to set it up in Notion. */
+export function scheduled(options?: RecurrenceSchedule): RecurrenceTrigger {
+	return { type: "recurrence", ...options };
+}
+
+/** Watch new rows in a declared data source, or configure the source in Notion. */
+export function notionPageCreated(options?: {
+	dataSource: DataSourceHandle;
+}): NotionPageCreatedTrigger {
+	return {
+		type: "notion.page.created",
+		...(options ? { dataSourceResourceId: options.dataSource.resourceId } : {}),
+	};
+}
+
+/** Watch typed properties and/or page content in a declared data source. */
+export function notionPageUpdated<const Schema extends NotionAsCodeSchema>(
+	options?: PageUpdatedOptions<Schema>,
+): NotionPageUpdatedTrigger {
+	if (!options) return { type: "notion.page.updated" };
+	const { dataSource, properties = [], includePageContent = false } = options;
+	if (properties.length === 0 && !includePageContent) {
+		throw new Error("Page-updated events must watch at least one property or page content");
+	}
+	for (const property of properties) {
+		if (
+			property.dataSourceResourceId !== dataSource.resourceId ||
+			dataSource.properties[property.name]?.resourceId !== property.resourceId
+		) {
+			throw new Error(
+				`Property "${property.name}" does not belong to data source "${dataSource.resourceId}"`,
+			);
+		}
+	}
+	return {
+		type: "notion.page.updated",
+		dataSourceResourceId: dataSource.resourceId,
+		...(properties.length
+			? {
+					propertyResourceIds: [
+						...new Set(properties.map((property) => property.resourceId)),
+					],
+				}
+			: {}),
+		includePageContent,
+	};
+}

package/src/connections.ts

@@ -1,6 +1,6 @@
 import { validateOAuthConfiguration, type OAuthConfiguration } from "./oauth.js";
 import { connectionTriggerDefinitions } from "./connection-trigger-definitions.generated.js";
-import type { WorkflowTrigger } from "./triggers.generated.js";
+import type { WorkflowTrigger } from "./events.generated.js";
 import type { Client } from "@notionhq/client";
 import {
 	connections as providerConnections,

package/src/events-types.test.ts

@@ -0,0 +1,110 @@
+import { resolve } from "node:path";
+import ts from "typescript";
+import { expect, it } from "vitest";
+
+it("checks property references and schedule variants in user code", () => {
+	const cases = [
+		{
+			name: "property",
+			valid: true,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, properties: [tasks.dataSource.properties.Status] })",
+		},
+		{
+			name: "content",
+			valid: true,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, includePageContent: true })",
+		},
+		{
+			name: "typo",
+			valid: false,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, properties: [tasks.dataSource.properties.Statuz] })",
+		},
+		{
+			name: "string",
+			valid: false,
+			expression:
+				'events.notionPageUpdated({ dataSource: tasks.dataSource, properties: ["Status"] })',
+		},
+		{
+			name: "other_source",
+			valid: false,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, properties: [other.dataSource.properties.Name] })",
+		},
+		{
+			name: "unsupported_property",
+			valid: false,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, properties: [tasks.dataSource.properties.Files] })",
+		},
+		{
+			name: "empty",
+			valid: false,
+			expression:
+				"events.notionPageUpdated({ dataSource: tasks.dataSource, properties: [] })",
+		},
+		{
+			name: "no_watch",
+			valid: false,
+			expression: "events.notionPageUpdated({ dataSource: tasks.dataSource })",
+		},
+		{
+			name: "weekly",
+			valid: true,
+			expression:
+				'events.scheduled({ frequency: "week", interval: 1, weekdays: { MO: true }, start: "2026-09-23", timeZone: "UTC" })',
+		},
+		{
+			name: "no_weekday",
+			valid: false,
+			expression:
+				'events.scheduled({ frequency: "week", interval: 1, weekdays: {}, start: "2026-09-23", timeZone: "UTC" })',
+		},
+	];
+	const fixtures = new Map(
+		cases.map((testCase) => [
+			resolve("src", `__events_${testCase.name}.ts`),
+			`
+		import { database, events } from "./index.js";
+		const tasks = database("tasks", { name: "Tasks", dataSourceResourceId: "tasks-source", schema: {
+			Name: { type: "title", resourceId: "name" }, Status: { type: "select", resourceId: "status", options: [] }, Files: { type: "file", resourceId: "files" }
+		} });
+		const other = database("other", { name: "Other", dataSourceResourceId: "other-source", schema: {
+			Name: { type: "title", resourceId: "other-name" }
+		} });
+		${testCase.expression};
+	`,
+		]),
+	);
+	const config = ts.readConfigFile(resolve("tsconfig.json"), ts.sys.readFile);
+	const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, process.cwd());
+	const host = ts.createCompilerHost(parsed.options);
+	const getSourceFile = host.getSourceFile.bind(host);
+	host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+		const fixture = fixtures.get(fileName);
+		return fixture === undefined
+			? getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile)
+			: ts.createSourceFile(fileName, fixture, languageVersion, true);
+	};
+	const program = ts.createProgram(
+		[...fixtures.keys()],
+		{ ...parsed.options, noEmit: true },
+		host,
+	);
+	const diagnostics = ts.getPreEmitDiagnostics(program);
+	expect(
+		diagnostics.filter(
+			(diagnostic) => !diagnostic.file || !fixtures.has(diagnostic.file.fileName),
+		),
+	).toEqual([]);
+	for (const testCase of cases) {
+		const errors = diagnostics.filter(
+			(diagnostic) =>
+				diagnostic.file?.fileName === resolve("src", `__events_${testCase.name}.ts`),
+		);
+		expect(errors.length === 0, testCase.name).toBe(testCase.valid);
+	}
+});

package/src/{triggers.generated.ts → events.generated.ts}

@@ -1,7 +1,12 @@
-// Generated by scripts/generate-triggers.ts — do not edit by hand.
+// Generated by scripts/generate-events.ts — do not edit by hand.
 // Regenerate with: pnpm run generate
 
 import type { WorkflowConnectionDeclarations, WorkflowConnectionKeys } from "./connections.js";
+import { scheduled, notionPageCreated, notionPageUpdated } from "./configured-events.js";
+import type { NotionPageCreatedTrigger, NotionPageUpdatedTrigger, PageUpdatedOptions, RecurrenceTrigger } from "./configured-events.js";
+import type { DataSourceHandle } from "./notion-as-code/database.js";
+import type { NotionAsCodeSchema } from "./notion-as-code/intents.js";
+import type { RecurrenceSchedule } from "./notion-as-code/recurrence.js";
 
 import type {
 	CalendarEventCanceledEvent,
@@ -25,7 +30,7 @@ import type {
 	SlackMessageEvent,
 	SlackReactionAddedEvent,
 	WebhookEvent,
-} from "./triggers.js";
+} from "./events.js";
 
 export type {
 	Actor,
@@ -72,7 +77,10 @@ export type {
 	VendorActor,
 	VendorExtensions,
 	WebhookEvent,
-} from "./triggers.js";
+} from "./events.js";
+
+export type { NotionPageCreatedTrigger, NotionPageUpdatedTrigger, PageUpdatedOptions, RecurrenceTrigger } from "./configured-events.js";
+export type { RecurrenceSchedule } from "./notion-as-code/recurrence.js";
 
 /** Triggers immediately after a new message is posted in Slack (includes new threads and replies) */
 export type SlackMessageTrigger<TKey extends string = string> = {
@@ -144,16 +152,6 @@ export type CalendarEventCanceledTrigger<TKey extends string = string> = {
 	connectionKey?: TKey;
 };
 
-/** A page has been added to a database. */
-export type NotionPageCreatedTrigger = {
-	type: "notion.page.created";
-};
-
-/** A page was updated. */
-export type NotionPageUpdatedTrigger = {
-	type: "notion.page.updated";
-};
-
 /** A page was deleted. */
 export type NotionPageDeletedTrigger = {
 	type: "notion.page.deleted";
@@ -196,13 +194,8 @@ export type GoogleDriveOauthFilesChangedTrigger<TKey extends string = string> =
 	connectionKey?: TKey;
 };
 
-/** A recurring schedule fired. */
-export type RecurrenceTrigger = {
-	type: "recurrence";
-};
-
 /** Creators for each event that can trigger a workflow. */
-export const triggers = {
+export const events = {
 	/**
 	 * Declare that a workflow can run on `slack.message` events.
 	 *
@@ -323,27 +316,9 @@ export const triggers = {
 		};
 	},
 
-	/**
-	 * Declare that a workflow can run on `notion.page.created` events.
-	 *
-	 * A page has been added to a database.
-	 */
-	notionPageCreated(): NotionPageCreatedTrigger {
-		return {
-			type: "notion.page.created",
-		};
-	},
+	notionPageCreated,
 
-	/**
-	 * Declare that a workflow can run on `notion.page.updated` events.
-	 *
-	 * A page was updated.
-	 */
-	notionPageUpdated(): NotionPageUpdatedTrigger {
-		return {
-			type: "notion.page.updated",
-		};
-	},
+	notionPageUpdated,
 
 	/**
 	 * Declare that a workflow can run on `notion.page.deleted` events.
@@ -434,20 +409,11 @@ export const triggers = {
 		};
 	},
 
-	/**
-	 * Declare that a workflow can run on `recurrence` events.
-	 *
-	 * A recurring schedule fired.
-	 */
-	scheduled(): RecurrenceTrigger {
-		return {
-			type: "recurrence",
-		};
-	},
+	scheduled,
 } as const;
 
 /** Trigger creators restricted to the workflow's declared provider keys. */
-export type WorkflowTriggerCreators<TConnections extends WorkflowConnectionDeclarations> = {
+export type WorkflowEventCreators<TConnections extends WorkflowConnectionDeclarations> = {
 	slackMessage(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackMessageTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	slackReactionAdded(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	slackAppMention(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
@@ -458,8 +424,8 @@ export type WorkflowTriggerCreators<TConnections extends WorkflowConnectionDecla
 	calendarEventCreated(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventCreatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
 	calendarEventUpdated(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventUpdatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
 	calendarEventCanceled(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventCanceledTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
-	notionPageCreated(): NotionPageCreatedTrigger;
-	notionPageUpdated(): NotionPageUpdatedTrigger;
+	notionPageCreated(options?: { dataSource: DataSourceHandle }): NotionPageCreatedTrigger;
+	notionPageUpdated<const Schema extends NotionAsCodeSchema>(options?: PageUpdatedOptions<Schema>): NotionPageUpdatedTrigger;
 	notionPageDeleted(): NotionPageDeletedTrigger;
 	notionMeetingNoteSummaryCompleted(): NotionMeetingNoteSummaryCompletedTrigger;
 	notionCommentAdded(): NotionCommentAddedTrigger;
@@ -468,7 +434,7 @@ export type WorkflowTriggerCreators<TConnections extends WorkflowConnectionDecla
 	notionDatabaseAgentUpdated(): NotionDatabaseAgentUpdatedTrigger;
 	webhook(): WebhookTrigger;
 	googleDriveOauthFilesChanged(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "googleDriveOauth"> }): GoogleDriveOauthFilesChangedTrigger<WorkflowConnectionKeys<TConnections, "googleDriveOauth">>;
-	scheduled(): RecurrenceTrigger;
+	scheduled(options?: RecurrenceSchedule): RecurrenceTrigger;
 };
 
 /** Triggers whose connection keys belong to the declared provider. */
@@ -496,8 +462,8 @@ export type WorkflowTriggerForConnections<TConnections extends WorkflowConnectio
 	| RecurrenceTrigger;
 
 /** @internal */
-export function createWorkflowTriggers<TConnections extends WorkflowConnectionDeclarations>(): WorkflowTriggerCreators<TConnections> {
-	return triggers;
+export function createWorkflowEvents<TConnections extends WorkflowConnectionDeclarations>(): WorkflowEventCreators<TConnections> {
+	return events;
 }
 
 /** Event that can trigger a workflow. */

package/src/index.ts

@@ -1,3 +1,4 @@
+export { events } from "./events.generated.js";
 export { customBlock, type CustomBlockHandle } from "./custom-block.js";
 export { customAgent } from "./notion-as-code/custom-agent.js";
 export { database } from "./notion-as-code/database.js";

package/src/notion-as-code/custom-agent.test.ts

@@ -18,7 +18,8 @@ describe("Notion-as-Code custom agent declarations", () => {
 			resourceId: "triage-agent",
 			name: "Triage agent",
 			webAccess: true,
-			trustedUrls: { type: "all" },
+			browserUse: true,
+			trustedUrls: ["docs.example.com/*", "support.example.com"],
 			access: [access.edit(tasks)],
 			triggers: [
 				{
@@ -30,6 +31,11 @@ describe("Notion-as-Code custom agent declarations", () => {
 					timeZone: "America/Los_Angeles",
 					weekdays: { MO: true, FR: true },
 				},
+				{
+					type: "page_added",
+					resourceId: "task-added-trigger",
+					dataSourceResourceId: "tasks",
+				},
 				{
 					type: "property_updated",
 					resourceId: "task-update-trigger",
@@ -48,7 +54,8 @@ describe("Notion-as-Code custom agent declarations", () => {
 				resourceId: "triage-agent",
 				name: "Triage agent",
 				webAccess: true,
-				trustedUrls: { type: "all" },
+				browserUse: true,
+				trustedUrls: { type: "list", urls: ["docs.example.com/*", "support.example.com"] },
 				access: [{ resourceId: "tasks-db", level: "edit" }],
 				triggers: [
 					{
@@ -60,9 +67,16 @@ describe("Notion-as-Code custom agent declarations", () => {
 						timeZone: "America/Los_Angeles",
 						weekdays: { MO: true, FR: true },
 					},
+					{
+						type: "page_added",
+						resourceId: "task-added-trigger",
+						dataSourceResourceId: "tasks",
+						waitForEditsToFinish: false,
+					},
 					{
 						type: "property_updated",
 						resourceId: "task-update-trigger",
+						waitForEditsToFinish: false,
 						dataSourceResourceId: "tasks",
 						propertyConditions: {
 							status: { type: "property_edited" },
@@ -74,6 +88,72 @@ describe("Notion-as-Code custom agent declarations", () => {
 		]);
 	});
 
+	it("records browser disablement and no trusted URLs", () => {
+		const recorder = startMetadataRecording();
+		notion.customAgent({
+			resourceId: "triage-agent",
+			name: "Triage agent",
+			browserUse: false,
+			trustedUrls: "none",
+		});
+		expect(finishMetadataRecording(recorder).intents).toEqual([
+			{
+				type: "custom_agent",
+				resourceId: "triage-agent",
+				name: "Triage agent",
+				browserUse: false,
+				trustedUrls: { type: "list", urls: [] },
+			},
+		]);
+	});
+
+	it("records unrestricted trust and an explicit wait for edits", () => {
+		const recorder = startMetadataRecording();
+		notion.customAgent({
+			resourceId: "triage-agent",
+			name: "Triage agent",
+			trustedUrls: "all",
+			triggers: [
+				{
+					type: "page_added",
+					resourceId: "task-added-trigger",
+					dataSourceResourceId: "tasks",
+					waitForEditsToFinish: true,
+				},
+				{
+					type: "property_updated",
+					resourceId: "task-update-trigger",
+					dataSourceResourceId: "tasks",
+					triggerWhenPageContentEdited: true,
+					waitForEditsToFinish: true,
+				},
+			],
+		});
+		expect(finishMetadataRecording(recorder).intents).toEqual([
+			{
+				type: "custom_agent",
+				resourceId: "triage-agent",
+				name: "Triage agent",
+				trustedUrls: { type: "all" },
+				triggers: [
+					{
+						type: "page_added",
+						resourceId: "task-added-trigger",
+						dataSourceResourceId: "tasks",
+						waitForEditsToFinish: true,
+					},
+					{
+						type: "property_updated",
+						resourceId: "task-update-trigger",
+						dataSourceResourceId: "tasks",
+						triggerWhenPageContentEdited: true,
+						waitForEditsToFinish: true,
+					},
+				],
+			},
+		]);
+	});
+
 	it("rejects reserved resource IDs inside triggers", () => {
 		expect(() =>
 			notion.customAgent({