@notionhq/apps 0.0.17 → 0.0.18

package/src/cli/build.test.ts

@@ -15,17 +15,18 @@ import { finishMetadataRecording, startMetadataRecording } from "../notion-as-co
 describe("Notion-as-Code database shorthand", () => {
 	it("keeps provisioning and sync identity equivalent to an explicit source", () => {
 		const recorder = startMetadataRecording();
-		const database = notion.database({
-			resourceId: "issues",
+		const schema = {
+			Name: { resourceId: "title", type: "title" },
+			Count: { resourceId: "count", type: "number" },
+		} as const;
+		const database = notion.database("issues", {
+			dataSourceResourceId: "issues-source",
 			name: "Issues",
-			properties: [
-				{ resourceId: "title", name: "Name", type: "title" },
-				{ resourceId: "count", name: "Count", type: "number" },
-			],
+			schema,
 		});
-		expectTypeOf(database).toExtend<
-			SingleSourceDatabaseHandle<typeof database.dataSource.schema>
-		>();
+		expectTypeOf(database).toExtend<SingleSourceDatabaseHandle<typeof schema>>();
+		expectTypeOf(database.dataSource.schema.Name.type).toEqualTypeOf<"title">();
+		expectTypeOf(database.dataSource.schema.Name.resourceId).toEqualTypeOf<"title">();
 		expectTypeOf(
 			database.dataSource.database.config.schema.Count.type,
 		).toEqualTypeOf<"number">();
@@ -33,18 +34,19 @@ describe("Notion-as-Code database shorthand", () => {
 		const shorthand = finishMetadataRecording(recorder).intents;
 
 		const explicitRecorder = startMetadataRecording();
-		const explicit = notion.database({
-			resourceId: "issues",
+		const explicit = notion.database("issues", {
 			name: "Issues",
-			dataSources: [
-				{
+			datasources: {
+				Issues: {
 					resourceId: "issues-source",
-					name: "Issues",
-					properties: database.dataSource.schema,
+					schema,
 				},
-			],
+			},
 		});
-		explicit.dataSources["issues-source"].addPage({ resourceId: "issue" });
+		expectTypeOf(explicit.datasources.Issues).toExtend<DataSourceHandle<typeof schema>>();
+		expectTypeOf(explicit.datasources.Issues.schema.Name.type).toEqualTypeOf<"title">();
+		expectTypeOf(explicit.datasources.Issues.schema.Name.resourceId).toEqualTypeOf<"title">();
+		explicit.datasources.Issues.addPage({ resourceId: "issue" });
 		// @ts-expect-error Explicit databases do not guarantee a single source.
 		void explicit.dataSource;
 		expect(shorthand).toEqual(finishMetadataRecording(explicitRecorder).intents);
@@ -56,22 +58,24 @@ describe("Notion-as-Code database shorthand", () => {
 		});
 	});
 
-	it("preserves parent binding and inferred source types through child helpers", () => {
+	it("preserves parent binding and keyed source types through child helpers", () => {
 		const recorder = startMetadataRecording();
 		const page = notion.page({ resourceId: "page" });
 		const team = notion.teamspace({ resourceId: "team", name: "Team", accessLevel: "private" });
+		const schema = {
+			Title: { resourceId: "child-title", type: "title" },
+		} as const;
 		for (const parent of [page, team]) {
-			const database = parent.addDatabase({
-				resourceId: `${parent.resourceId}-db`,
+			const database = parent.addDatabase(`${parent.resourceId}-db`, {
+				dataSourceResourceId: `${parent.resourceId}-source`,
 				name: "Child",
-				properties: [
-					{ resourceId: `${parent.resourceId}-title`, name: "Title", type: "title" },
-				],
+				schema,
 			});
-			expectTypeOf(database.dataSource).toExtend<
-				DataSourceHandle<typeof database.dataSource.schema>
-			>();
-			expectTypeOf(database.dataSource.schema[0].name).toEqualTypeOf<"Title">();
+			expectTypeOf(database.dataSource).toExtend<DataSourceHandle<typeof schema>>();
+			expectTypeOf(database.dataSource.schema.Title.type).toEqualTypeOf<"title">();
+			expectTypeOf(
+				database.dataSource.schema.Title.resourceId,
+			).toEqualTypeOf<"child-title">();
 		}
 		const intents = finishMetadataRecording(recorder).intents;
 		expect(
@@ -82,19 +86,60 @@ describe("Notion-as-Code database shorthand", () => {
 		]);
 	});
 
-	it("rejects mixed forms before recording an intent", () => {
+	it("keeps keyed child inference and rejects empty child databases", () => {
 		const recorder = startMetadataRecording();
-		const declareMixedDatabase = () => {
-			// @ts-expect-error The shorthand and explicit forms are mutually exclusive.
-			notion.database({
-				resourceId: "mixed",
-				name: "Mixed",
-				properties: [],
-				dataSources: [],
-			});
+		const page = notion.page({ resourceId: "child-page" });
+		const schema = {
+			Name: { type: "title", resourceId: "child-name" },
+			"Issue ID": { type: "text", resourceId: "child-issue-id" },
+		} as const;
+		const database = page.addDatabase("child-multi-database", {
+			datasources: {
+				Issues: {
+					resourceId: "child-issues-source",
+					schema,
+				},
+			},
+		});
+		expectTypeOf(database.datasources.Issues).toExtend<DataSourceHandle<typeof schema>>();
+		expectTypeOf(
+			database.datasources.Issues.schema.Name.resourceId,
+		).toEqualTypeOf<"child-name">();
+
+		const invalidChildDeclarations = () => {
+			// @ts-expect-error Child databases need a source or a view.
+			page.addDatabase("child-empty-datasources", { datasources: {} });
+			// @ts-expect-error Child databases need a source or a view.
+			page.addDatabase("child-empty-arguments", {});
+			// @ts-expect-error Empty child sources and views are invalid.
+			page.addDatabase("child-empty-with-views", { datasources: {}, views: [] });
 		};
-		expect(declareMixedDatabase).toThrow();
-		expect(finishMetadataRecording(recorder).intents).toEqual([]);
+		void invalidChildDeclarations;
+		expect(() =>
+			page.addDatabase("child-runtime-empty", { datasources: {}, views: [] } as never),
+		).toThrow();
+
+		const intents = finishMetadataRecording(recorder).intents;
+		expect(intents).toHaveLength(2);
+		expect(intents).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					type: "database",
+					resourceId: "child-multi-database",
+					parent: { type: "resourceId", resourceId: "child-page" },
+					dataSources: [
+						{
+							resourceId: "child-issues-source",
+							name: "Issues",
+							properties: [
+								{ resourceId: "child-name", name: "Name", type: "title" },
+								{ resourceId: "child-issue-id", name: "Issue ID", type: "text" },
+							],
+						},
+					],
+				}),
+			]),
+		);
 	});
 });
 
@@ -163,41 +208,49 @@ describe("buildApp", () => {
 	it("builds a sync manifest with a Notion-as-Code meetings database", async () => {
 		const { manifest } = await buildApp(example("sync"));
 
-		expect(manifest).toEqual({
-			$schema: "notion:apps-manifest:v1",
-			sdkVersion: SDK_VERSION,
-			databases: [
-				{
+		expect(manifest).toEqual(
+			expect.objectContaining({
+				$schema: "notion:apps-manifest:v1",
+				sdkVersion: SDK_VERSION,
+				xldbs: [],
+				pacers: [],
+			}),
+		);
+		expect(manifest.databases).toHaveLength(2);
+		expect(manifest.databases).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
 					key: "issues",
-					config: {
+					config: expect.objectContaining({
 						initialTitle: "GitHub Issues",
-						schema: {
-							properties: {
+						schema: expect.objectContaining({
+							properties: expect.objectContaining({
 								Name: { type: "title" },
 								"GitHub ID": { type: "text" },
 								Closed: { type: "checkbox" },
-							},
-						},
-					},
-				},
-				{
+							}),
+						}),
+					}),
+				}),
+				expect.objectContaining({
 					key: "homebase-meetings-db-source",
-					config: {
+					config: expect.objectContaining({
 						initialTitle: "Meetings",
-						schema: {
-							properties: {
+						schema: expect.objectContaining({
+							properties: expect.objectContaining({
 								Name: { type: "title" },
 								"Meeting ID": { type: "text" },
 								"Meeting date": { type: "date" },
 								"Prep complete": { type: "checkbox" },
-							},
-						},
-					},
-				},
-			],
-			xldbs: [],
-			pacers: [],
-			capabilities: [
+							}),
+						}),
+					}),
+				}),
+			]),
+		);
+		expect(manifest.capabilities).toHaveLength(2);
+		expect(manifest.capabilities).toEqual(
+			expect.arrayContaining([
 				{
 					type: "sync",
 					key: "issues",
@@ -218,8 +271,8 @@ describe("buildApp", () => {
 						schedule: { type: "interval", intervalMs: 3_600_000 },
 					},
 				},
-			],
-		});
+			]),
+		);
 	});
 
 	it("emits a separate Notion-as-Code provisioning artifact", async () => {
@@ -285,6 +338,13 @@ describe("buildApp", () => {
 						resourceId: "__notion_apps_workspace__",
 					},
 					dataSources: [],
+					views: [
+						{
+							resourceId: "github-app-private-view",
+							type: "table",
+							dataSourceResourceId: "issues-source",
+						},
+					],
 				},
 				{
 					type: "database",

package/src/index.ts

@@ -6,3 +6,4 @@ export { teamspace } from "./notion-as-code/teamspace.js";
 export { view } from "./notion-as-code/view.js";
 export { sync } from "./sync.js";
 export { workflow } from "./workflow.js";
+export type { WorkflowState, WorkflowStateValue } from "./workflow-state.js";