@notionhq/apps 0.0.16 → 0.0.18

package/src/providers.generated.ts

@@ -27,181 +27,86 @@ export const connections = {
 	outlook,
 	salesforce,
 }
-export type ConnectionProviders = {
-	calendar(key?: string): CalendarConnectionClient
-	slack(key?: string): SlackConnectionClient
-	googleDriveOauth(key?: string): GoogleDriveOauthConnectionClient
-	discord(key?: string): DiscordConnectionClient
-	cursor(key?: string): CursorConnectionClient
-	box(key?: string): BoxConnectionClient
-	confluence(key?: string): ConfluenceConnectionClient
-	gmail(key?: string): GmailConnectionClient
-	googleCalendar(key?: string): GoogleCalendarConnectionClient
-	googleDrive(key?: string): GoogleDriveConnectionClient
-	outlook(key?: string): OutlookConnectionClient
-	salesforce(key?: string): SalesforceConnectionClient
+export type ConnectionClients = {
+	calendar: CalendarConnectionClient
+	slack: SlackConnectionClient
+	googleDriveOauth: GoogleDriveOauthConnectionClient
+	discord: DiscordConnectionClient
+	cursor: CursorConnectionClient
+	box: BoxConnectionClient
+	confluence: ConfluenceConnectionClient
+	gmail: GmailConnectionClient
+	googleCalendar: GoogleCalendarConnectionClient
+	googleDrive: GoogleDriveConnectionClient
+	outlook: OutlookConnectionClient
+	salesforce: SalesforceConnectionClient
 }
-export function createConnectionProviders(
-	invoker: (provider: string, key: string) => ConnectionActionInvoker,
-): ConnectionProviders {
-	return {
-		calendar(key = "calendar"): CalendarConnectionClient {
-			return new CalendarConnectionClient(invoker("calendar", key))
-		},
-		slack(key = "slack"): SlackConnectionClient {
-			return new SlackConnectionClient(invoker("slack", key))
-		},
-		googleDriveOauth(
-			key = "googleDriveOauth",
-		): GoogleDriveOauthConnectionClient {
-			return new GoogleDriveOauthConnectionClient(
-				invoker("googleDriveOauth", key),
-			)
-		},
-		discord(key = "discord"): DiscordConnectionClient {
-			return new DiscordConnectionClient(invoker("discord", key))
-		},
-		cursor(key = "cursor"): CursorConnectionClient {
-			return new CursorConnectionClient(invoker("cursor", key))
-		},
-		box(key = "box"): BoxConnectionClient {
-			return new BoxConnectionClient(invoker("box", key))
-		},
-		confluence(key = "confluence"): ConfluenceConnectionClient {
-			return new ConfluenceConnectionClient(invoker("confluence", key))
-		},
-		gmail(key = "gmail"): GmailConnectionClient {
-			return new GmailConnectionClient(invoker("gmail", key))
-		},
-		googleCalendar(key = "googleCalendar"): GoogleCalendarConnectionClient {
-			return new GoogleCalendarConnectionClient(invoker("googleCalendar", key))
-		},
-		googleDrive(key = "googleDrive"): GoogleDriveConnectionClient {
-			return new GoogleDriveConnectionClient(invoker("googleDrive", key))
-		},
-		outlook(key = "outlook"): OutlookConnectionClient {
-			return new OutlookConnectionClient(invoker("outlook", key))
-		},
-		salesforce(key = "salesforce"): SalesforceConnectionClient {
-			return new SalesforceConnectionClient(invoker("salesforce", key))
-		},
+export function createConnectionClient(
+	provider: string,
+	invoker: ConnectionActionInvoker,
+): ConnectionClients[keyof ConnectionClients] {
+	switch (provider) {
+		case "calendar":
+			return new CalendarConnectionClient(invoker)
+		case "slack":
+			return new SlackConnectionClient(invoker)
+		case "googleDriveOauth":
+			return new GoogleDriveOauthConnectionClient(invoker)
+		case "discord":
+			return new DiscordConnectionClient(invoker)
+		case "cursor":
+			return new CursorConnectionClient(invoker)
+		case "box":
+			return new BoxConnectionClient(invoker)
+		case "confluence":
+			return new ConfluenceConnectionClient(invoker)
+		case "gmail":
+			return new GmailConnectionClient(invoker)
+		case "googleCalendar":
+			return new GoogleCalendarConnectionClient(invoker)
+		case "googleDrive":
+			return new GoogleDriveConnectionClient(invoker)
+		case "outlook":
+			return new OutlookConnectionClient(invoker)
+		case "salesforce":
+			return new SalesforceConnectionClient(invoker)
+		default:
+			throw new Error("Unsupported connection provider: " + provider)
 	}
 }
-function calendar(options?: {
-	key?: never
-}): WorkflowConnection<"calendar", "calendar">
-function calendar<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"calendar", TKey>
-function calendar(
-	options: { key?: string } = {},
-): WorkflowConnection<"calendar"> {
-	return { type: "calendar", ...options }
+function calendar(): WorkflowConnection<"calendar"> {
+	return { type: "calendar" }
 }
-function slack(options?: { key?: never }): WorkflowConnection<"slack", "slack">
-function slack<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"slack", TKey>
-function slack(options: { key?: string } = {}): WorkflowConnection<"slack"> {
-	return { type: "slack", ...options }
+function slack(): WorkflowConnection<"slack"> {
+	return { type: "slack" }
 }
-function googleDriveOauth(options?: {
-	key?: never
-}): WorkflowConnection<"googleDriveOauth", "googleDriveOauth">
-function googleDriveOauth<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"googleDriveOauth", TKey>
-function googleDriveOauth(
-	options: { key?: string } = {},
-): WorkflowConnection<"googleDriveOauth"> {
-	return { type: "googleDriveOauth", ...options }
+function googleDriveOauth(): WorkflowConnection<"googleDriveOauth"> {
+	return { type: "googleDriveOauth" }
 }
-function discord(options?: {
-	key?: never
-}): WorkflowConnection<"discord", "discord">
-function discord<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"discord", TKey>
-function discord(
-	options: { key?: string } = {},
-): WorkflowConnection<"discord"> {
-	return { type: "discord", ...options }
+function discord(): WorkflowConnection<"discord"> {
+	return { type: "discord" }
 }
-function cursor(options?: {
-	key?: never
-}): WorkflowConnection<"cursor", "cursor">
-function cursor<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"cursor", TKey>
-function cursor(options: { key?: string } = {}): WorkflowConnection<"cursor"> {
-	return { type: "cursor", ...options }
+function cursor(): WorkflowConnection<"cursor"> {
+	return { type: "cursor" }
 }
-function box(options?: { key?: never }): WorkflowConnection<"box", "box">
-function box<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"box", TKey>
-function box(options: { key?: string } = {}): WorkflowConnection<"box"> {
-	return { type: "box", ...options }
+function box(): WorkflowConnection<"box"> {
+	return { type: "box" }
 }
-function confluence(options?: {
-	key?: never
-}): WorkflowConnection<"confluence", "confluence">
-function confluence<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"confluence", TKey>
-function confluence(
-	options: { key?: string } = {},
-): WorkflowConnection<"confluence"> {
-	return { type: "confluence", ...options }
+function confluence(): WorkflowConnection<"confluence"> {
+	return { type: "confluence" }
 }
-function gmail(options?: { key?: never }): WorkflowConnection<"gmail", "gmail">
-function gmail<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"gmail", TKey>
-function gmail(options: { key?: string } = {}): WorkflowConnection<"gmail"> {
-	return { type: "gmail", ...options }
+function gmail(): WorkflowConnection<"gmail"> {
+	return { type: "gmail" }
 }
-function googleCalendar(options?: {
-	key?: never
-}): WorkflowConnection<"googleCalendar", "googleCalendar">
-function googleCalendar<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"googleCalendar", TKey>
-function googleCalendar(
-	options: { key?: string } = {},
-): WorkflowConnection<"googleCalendar"> {
-	return { type: "googleCalendar", ...options }
+function googleCalendar(): WorkflowConnection<"googleCalendar"> {
+	return { type: "googleCalendar" }
 }
-function googleDrive(options?: {
-	key?: never
-}): WorkflowConnection<"googleDrive", "googleDrive">
-function googleDrive<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"googleDrive", TKey>
-function googleDrive(
-	options: { key?: string } = {},
-): WorkflowConnection<"googleDrive"> {
-	return { type: "googleDrive", ...options }
+function googleDrive(): WorkflowConnection<"googleDrive"> {
+	return { type: "googleDrive" }
 }
-function outlook(options?: {
-	key?: never
-}): WorkflowConnection<"outlook", "outlook">
-function outlook<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"outlook", TKey>
-function outlook(
-	options: { key?: string } = {},
-): WorkflowConnection<"outlook"> {
-	return { type: "outlook", ...options }
+function outlook(): WorkflowConnection<"outlook"> {
+	return { type: "outlook" }
 }
-function salesforce(options?: {
-	key?: never
-}): WorkflowConnection<"salesforce", "salesforce">
-function salesforce<const TKey extends string>(options: {
-	key: TKey
-}): WorkflowConnection<"salesforce", TKey>
-function salesforce(
-	options: { key?: string } = {},
-): WorkflowConnection<"salesforce"> {
-	return { type: "salesforce", ...options }
+function salesforce(): WorkflowConnection<"salesforce"> {
+	return { type: "salesforce" }
 }

package/src/sync.test.ts

@@ -36,6 +36,20 @@ const keyTypes = createDatabase("key-types", {
 		Project: Schema.relation(projects),
 	},
 });
+const partialMeetings = createDatabase("partial-meetings", {
+	schema: {
+		Name: Schema.title(),
+		"Meeting ID": Schema.richText(),
+		Other: Schema.richText(),
+		"Meeting date": Schema.date(),
+		"Prep complete": Schema.checkbox(),
+	},
+});
+const keyOnly = createDatabase("key-only", {
+	schema: {
+		ID: Schema.richText(),
+	},
+});
 
 type IssueKey = KeyPropertyName<typeof issues.config.schema>;
 const textKey: IssueKey = "GitHub ID";
@@ -128,6 +142,188 @@ describe("createSync", () => {
 		).toBe("GitHub ID");
 	});
 
+	it("accepts partial upsert properties in standalone handlers", () => {
+		const finiteProperties = {
+			Name: Builder.title("Prepared"),
+			Unknown: Builder.text("unexpected"),
+		};
+		const spreadProperties = {
+			Unknown: Builder.text("unexpected from spread"),
+		};
+
+		createSync({
+			database: partialMeetings,
+			primaryKey: "Meeting ID",
+			handler: async (state: { cursor: number } | undefined) => ({
+				changes: [
+					{
+						type: "upsert",
+						key: "meeting-1",
+						properties: { Name: Builder.title("One") },
+					},
+					{
+						type: "upsert",
+						key: "meeting-2",
+						properties: {
+							"Meeting date": Builder.date("2026-09-16"),
+							"Prep complete": Builder.checkbox(true),
+						},
+					},
+					{ type: "delete", key: "meeting-3" },
+				],
+				nextState: { cursor: (state?.cursor ?? 0) + 1 },
+			}),
+		});
+
+		const invalidSyncDeclarations = () => {
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Unknown property keys are rejected in inferred handler returns.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-inline",
+							properties: {
+								Name: Builder.title("Known"),
+								Unknown: Builder.text("unexpected"),
+							},
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Unknown properties remain rejected when another change shares the key.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "same",
+							properties: {
+								Name: Builder.title("Known"),
+								Unknown: Builder.text("unexpected"),
+							},
+						},
+						{
+							type: "upsert",
+							key: "same",
+							properties: { Name: Builder.title("Known sibling") },
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Upsert properties must include a non-primary-key schema property.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-empty",
+							properties: {},
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Finite property objects cannot contain unknown keys.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-finite",
+							properties: finiteProperties,
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Spread property objects cannot contain unknown keys.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-spread",
+							properties: {
+								Name: Builder.title("Known from spread"),
+								...spreadProperties,
+							},
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error Known properties must use their declared value types.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-value",
+							properties: {
+								Name: Builder.people("person@example.com"),
+							},
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				primaryKey: "Meeting ID",
+				// @ts-expect-error The primary-key property is supplied from change.key.
+				handler: async () => ({
+					changes: [
+						{
+							type: "upsert",
+							key: "invalid-primary-property",
+							properties: {
+								"Meeting ID": Builder.text("explicit"),
+							},
+						},
+					],
+				}),
+			});
+			createSync({
+				database: partialMeetings,
+				// @ts-expect-error Unknown schema properties cannot be sync primary keys.
+				primaryKey: "Unknown",
+				handler: async () => ({ changes: [] }),
+			});
+		};
+		void invalidSyncDeclarations;
+	});
+
+	it("rejects key-only upserts but allows deletes", () => {
+		const invalidKeyOnlyUpsert = () => {
+			createSync({
+				database: keyOnly,
+				primaryKey: "ID",
+				// @ts-expect-error Upserts require at least one non-primary-key schema property.
+				handler: async () => ({
+					changes: [{ type: "upsert", key: "invalid-key-only", properties: {} }],
+				}),
+			});
+		};
+		void invalidKeyOnlyUpsert;
+
+		createSync({
+			database: keyOnly,
+			primaryKey: "ID",
+			handler: async () => ({
+				changes: [{ type: "delete", key: "deleted-key-only" }],
+			}),
+		});
+	});
+
 	it("rejects invalid schedules when the sync is created", () => {
 		expect(() =>
 			createSync({
@@ -177,6 +373,105 @@ describe("createSync", () => {
 		]);
 	});
 
+	it("preserves omitted properties, partial upserts, and deletes at runtime", async () => {
+		const sync = createSync({
+			database: partialMeetings,
+			primaryKey: "Meeting ID",
+			handler: async (state: { cursor: number } | undefined) => ({
+				changes: [
+					{
+						type: "upsert",
+						key: "meeting-1",
+						properties: { Name: Builder.title("One") },
+					},
+					{
+						type: "upsert",
+						key: "meeting-2",
+						properties: { Other: Builder.text("Only other") },
+					},
+					{
+						type: "upsert",
+						key: "meeting-3",
+						properties: {
+							"Meeting date": Builder.date("2026-09-16"),
+							"Prep complete": Builder.checkbox(true),
+						},
+					},
+					{ type: "delete", key: "meeting-4" },
+				],
+				nextState: { cursor: (state?.cursor ?? 0) + 1 },
+			}),
+		});
+
+		const result = await sync.handler({ state: { cursor: 4 } }, { concreteOutput: true });
+
+		expect(result).toEqual({
+			changes: [
+				{
+					type: "upsert",
+					key: "meeting-1",
+					properties: {
+						Name: [["One"]],
+						"Meeting ID": [["meeting-1"]],
+					},
+					targetDatabaseKey: "partial-meetings",
+				},
+				{
+					type: "upsert",
+					key: "meeting-2",
+					properties: {
+						Other: [["Only other"]],
+						"Meeting ID": [["meeting-2"]],
+					},
+					targetDatabaseKey: "partial-meetings",
+				},
+				{
+					type: "upsert",
+					key: "meeting-3",
+					properties: {
+						"Meeting date": [
+							["‣", [["d", { type: "date", start_date: "2026-09-16" }]]],
+						],
+						"Prep complete": [["Yes"]],
+						"Meeting ID": [["meeting-3"]],
+					},
+					targetDatabaseKey: "partial-meetings",
+				},
+				{
+					type: "delete",
+					key: "meeting-4",
+					targetDatabaseKey: "partial-meetings",
+				},
+			],
+			hasMore: false,
+			nextUserContext: { cursor: 5 },
+			nextPacerStates: {},
+		});
+	});
+
+	it("rejects empty upserts at runtime", async () => {
+		const sync = createSync({
+			database: partialMeetings,
+			primaryKey: "Meeting ID",
+			handler: async () => ({
+				changes: [
+					{
+						type: "upsert",
+						key: "meeting-empty",
+						properties: {},
+						icon: Builder.notionIcon("warning"),
+						cover: Builder.imageCover("https://example.com/empty-cover.png"),
+						pageContentMarkdown: "# Empty properties",
+					},
+				],
+			}),
+		} as never);
+
+		await expect(sync.handler(undefined, { concreteOutput: true })).rejects.toBeInstanceOf(
+			ExecutionError,
+		);
+	});
+
 	it("passes deletes, paging state, and incremental mode through", async () => {
 		const sync = createSync({
 			database: issues,