@notionhq/apps 0.0.10 → 0.0.12

package/src/cli/build.ts

@@ -4,9 +4,14 @@ import * as path from "node:path";
 import { rolldown } from "rolldown";
 
 import type { AppManifest } from "../manifest.js";
-import { generateEntry } from "./codegen.js";
-import { discoverCapabilities } from "./discover.js";
-import { extractManifest } from "./emit-manifest.js";
+import {
+	createProvisioningArtifact,
+	type RecordedProvisioning,
+} from "../notion-as-code/provisioning.js";
+import { clearRegisteredPacers } from "../pacer.js";
+import { generateEntry, generateMetadataEntry } from "./codegen.js";
+import { discoverCapabilities, type DiscoveredCapability } from "./discover.js";
+import { extractManifest, extractProvisioning } from "./emit-manifest.js";
 
 export type BuildResult = {
 	manifest: AppManifest;
@@ -16,8 +21,8 @@ export type BuildResult = {
 
 /**
  * Build an app project: discover capability files by convention, generate
- * the entry module, bundle it into a single `dist/worker.js`, and emit
- * `dist/manifest.json` describing every capability.
+ * the Worker and build-only metadata entries, bundle the Worker, and emit
+ * the Worker manifest plus any recorded Notion-as-Code provisioning artifact.
  */
 export async function buildApp(projectRoot: string): Promise<BuildResult> {
 	const capabilities = await discoverCapabilities(projectRoot);
@@ -49,9 +54,59 @@ export async function buildApp(projectRoot: string): Promise<BuildResult> {
 	}
 
 	const manifest = await extractManifest(bundlePath, capabilities);
-
 	const manifestPath = path.join(projectRoot, "dist", "manifest.json");
 	await fs.promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, "\t")}\n`);
 
+	await emitProvisioningArtifact(projectRoot, capabilities);
+
 	return { manifest, bundlePath, manifestPath };
 }
+
+/** Build Notion-as-Code metadata separately so it does not ship in the Worker bundle. */
+async function emitProvisioningArtifact(
+	projectRoot: string,
+	capabilities: readonly DiscoveredCapability[],
+): Promise<void> {
+	const entityProvisioning = await buildMetadata(projectRoot, capabilities);
+	if (entityProvisioning.intents.length === 0) return;
+
+	const artifact = createProvisioningArtifact(entityProvisioning.intents);
+	await fs.promises.writeFile(
+		path.join(projectRoot, "dist", "provisioning.json"),
+		`${JSON.stringify(artifact, null, "\t")}\n`,
+	);
+}
+
+/** Bundle capabilities separately to record their Notion-as-Code declarations without shipping them. */
+async function buildMetadata(
+	projectRoot: string,
+	capabilities: readonly DiscoveredCapability[],
+): Promise<RecordedProvisioning> {
+	const metadataEntryPath = path.join(projectRoot, ".notion", "metadata-entry.ts");
+	const metadataBundlePath = path.join(projectRoot, ".notion", "metadata.js");
+	await fs.promises.writeFile(metadataEntryPath, generateMetadataEntry(capabilities));
+	// Metadata evaluation imports capability modules; clear their process-global pacer registrations first.
+	clearRegisteredPacers();
+
+	try {
+		const metadataBundle = await rolldown({
+			input: metadataEntryPath,
+			platform: "node",
+			// Keep SDK packages external so the metadata bundle resolves the app's installed SDK.
+			external: (id) => !id.startsWith(".") && !path.isAbsolute(id),
+		});
+		try {
+			await metadataBundle.write({
+				format: "esm",
+				file: metadataBundlePath,
+				codeSplitting: false,
+			});
+		} finally {
+			await metadataBundle.close();
+		}
+		return await extractProvisioning(metadataBundlePath);
+	} finally {
+		clearRegisteredPacers();
+		await fs.promises.rm(metadataBundlePath, { force: true });
+	}
+}

package/src/cli/codegen.ts

@@ -49,3 +49,24 @@ export async function run(
 }
 `;
 }
+
+/**
+ * Generate the build-only metadata entry. Dynamic imports run after the
+ * recorder starts and remain isolated from the deployed Worker entry.
+ */
+export function generateMetadataEntry(capabilities: readonly DiscoveredCapability[]): string {
+	const imports = capabilities
+		.map((capability) => `await import(${JSON.stringify(`../${capability.sourcePath}`)});`)
+		.join("\n");
+
+	return `// Generated by \`notion-apps build\`. Do not edit.
+import {
+	finishMetadataRecording,
+	startMetadataRecording,
+} from "@notionhq/apps/notion-as-code/recorder";
+
+const recorder = startMetadataRecording();
+${imports}
+export default finishMetadataRecording(recorder);
+`;
+}

package/src/cli/discover.test.ts

@@ -28,6 +28,12 @@ describe("discoverCapabilities", () => {
 				key: "issues",
 				sourcePath: path.join("src", "syncs", "issues.ts"),
 			},
+			{
+				type: "sync",
+				tag: "sync",
+				key: "notionAsCodeIssues",
+				sourcePath: path.join("src", "syncs", "notionAsCodeIssues.ts"),
+			},
 		]);
 	});
 

package/src/cli/emit-manifest.ts

@@ -4,6 +4,10 @@ import { pathToFileURL } from "node:url";
 import { Ajv } from "ajv";
 
 import { APPS_MANIFEST_SCHEMA } from "../manifest.js";
+import {
+	isRecordedProvisioning,
+	type RecordedProvisioning,
+} from "../notion-as-code/provisioning.js";
 import type { AppManifest, DatabaseManifestEntry, PacerManifestEntry } from "../manifest.js";
 import { clearRegisteredPacers, registeredPacers } from "../pacer.js";
 import type { DiscoveredCapability } from "./discover.js";
@@ -291,6 +295,20 @@ export async function extractManifest(
 	return manifest as AppManifest;
 }
 
+/** Import the metadata bundle and return the provisioning declarations it recorded. */
+export async function extractProvisioning(bundlePath: string): Promise<RecordedProvisioning> {
+	const bundle = await importBundle(bundlePath);
+	if (
+		typeof bundle !== "object" ||
+		bundle === null ||
+		!("default" in bundle) ||
+		!isRecordedProvisioning(bundle.default)
+	) {
+		throw new Error("Metadata bundle did not export a Notion-as-Code provisioning record");
+	}
+	return bundle.default;
+}
+
 let importNonce = 0;
 
 async function importBundle(bundlePath: string): Promise<unknown> {

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

@@ -0,0 +1,30 @@
+import type { CustomAgentIntent, NotionAsCodeIcon, ResourceId } from "./intents.js";
+import { recordIntent } from "./recorder.js";
+import { assertUserResourceId } from "./resource.js";
+
+export type CustomAgentArgs = {
+	resourceId: ResourceId;
+	name: string;
+	icon?: Exclude<NotionAsCodeIcon, { type: "file" }>;
+	instructions?: string;
+	model?: "ambrosia-tart-high" | "opal-quince-medium" | "almond-croissant-low";
+	sharedResources?: readonly ResourceId[];
+	// TODO: Port custom agent trigger types.
+	triggers?: readonly unknown[];
+};
+
+export type CustomAgentHandle = {
+	readonly resourceId: string;
+};
+
+/** Declare a custom agent and validate every shared resource reference. */
+export function customAgent(args: CustomAgentArgs): CustomAgentHandle {
+	assertUserResourceId(args.resourceId);
+	for (const resourceId of args.sharedResources ?? []) {
+		assertUserResourceId(resourceId);
+	}
+	recordIntent({ type: "custom_agent", ...args } satisfies {
+		type: "custom_agent";
+	} & CustomAgentIntent);
+	return { resourceId: args.resourceId };
+}

package/src/notion-as-code/database.ts

@@ -0,0 +1,143 @@
+import type { Database } from "../database.js";
+import type {
+	DataSourceDefinition,
+	DatabaseIntent,
+	NotionAsCodeIcon,
+	NotionAsCodeProperty,
+	Parent,
+	ResourceId,
+} from "./intents.js";
+import { createPage, type ChildPageArgs, type PageHandle } from "./page.js";
+import { recordIntent } from "./recorder.js";
+import { assertParent, assertUserResourceId } from "./resource.js";
+import { createAppsDatabase, type AppsSchemaForProperties } from "./schema.js";
+
+/** Input for declaring a database and its optional data sources. */
+export type DatabaseArgs<
+	DataSources extends readonly DataSourceDefinition[] = readonly DataSourceDefinition[],
+> = {
+	resourceId: ResourceId;
+	parent: Parent;
+	dataSources?: DataSources;
+	// TODO: Port view types.
+	views?: readonly unknown[];
+	icon?: NotionAsCodeIcon;
+	// TODO: Port cover types.
+	cover?: unknown;
+	hideDataSourceTitle?: boolean;
+	hideDatabaseTitleIfEmpty?: boolean;
+	name?: string;
+	description?: string;
+};
+
+/** Input for adding a database beneath an existing resource. */
+export type ChildDatabaseArgs<
+	DataSources extends readonly DataSourceDefinition[] = readonly DataSourceDefinition[],
+> = Omit<DatabaseArgs<DataSources>, "parent">;
+
+/** Resolves one data source ID to the properties declared for it. */
+type DataSourcePropertiesForResourceId<
+	DataSources extends readonly DataSourceDefinition[],
+	ResourceId extends DataSources[number]["resourceId"],
+> =
+	Extract<DataSources[number], { resourceId: ResourceId }> extends DataSourceDefinition<
+		infer Properties
+	>
+		? Properties
+		: never;
+
+/** Handle for a data source and the Apps database it backs. */
+export type DataSourceHandle<
+	Properties extends readonly NotionAsCodeProperty[] = readonly NotionAsCodeProperty[],
+> = {
+	readonly resourceId: string;
+	readonly schema: Properties;
+	readonly database: Database<AppsSchemaForProperties<Properties>>;
+	addPage: (args: ChildPageArgs) => PageHandle;
+};
+
+/** Handle for a database with data sources indexed by resource ID. */
+export type DatabaseHandle<
+	DataSources extends readonly DataSourceDefinition[] = readonly DataSourceDefinition[],
+> = {
+	readonly resourceId: string;
+	readonly dataSources: {
+		readonly [ResourceId in DataSources[number]["resourceId"]]: DataSourceHandle<
+			DataSourcePropertiesForResourceId<DataSources, ResourceId>
+		>;
+	};
+	addView: (view: unknown) => void;
+};
+
+/** Declare a top-level database and its data sources. */
+export function database<const DataSources extends readonly DataSourceDefinition[]>(
+	args: DatabaseArgs<DataSources>,
+): DatabaseHandle<DataSources>;
+export function database(args: DatabaseArgs): DatabaseHandle {
+	assertParent(args.parent);
+	return createDatabase(args, args.parent);
+}
+
+/** Record a database declaration and create handles for each of its data sources. */
+export function createDatabase(args: DatabaseArgs, parent: Parent): DatabaseHandle {
+	assertUserResourceId(args.resourceId);
+	const dataSources = args.dataSources ?? [];
+	const dataSourceIds = new Set<string>();
+	const handles: Record<string, DataSourceHandle> = {};
+
+	for (const dataSource of dataSources) {
+		assertUserResourceId(dataSource.resourceId);
+		if (dataSourceIds.has(dataSource.resourceId)) {
+			throw new Error(
+				`Database "${args.resourceId}" has duplicate data source "${dataSource.resourceId}"`,
+			);
+		}
+		dataSourceIds.add(dataSource.resourceId);
+		handles[dataSource.resourceId] = createDataSourceHandle(dataSource);
+	}
+
+	recordIntent({
+		type: "database",
+		...args,
+		parent,
+		dataSources: [...dataSources],
+	} satisfies { type: "database" } & DatabaseIntent);
+
+	return {
+		resourceId: args.resourceId,
+		dataSources: handles,
+		addView(view) {
+			recordIntent({ type: "view", databaseResourceId: args.resourceId, view });
+		},
+	};
+}
+
+/** Create a data source handle backed by the Apps database used by syncs. */
+function createDataSourceHandle(dataSource: DataSourceDefinition): DataSourceHandle {
+	const propertyResourceIds = new Set<string>();
+	const propertyNames = new Set<string>();
+	for (const property of dataSource.properties) {
+		assertUserResourceId(property.resourceId);
+		if (propertyResourceIds.has(property.resourceId)) {
+			throw new Error(
+				`Data source "${dataSource.resourceId}" has duplicate property resourceId "${property.resourceId}"`,
+			);
+		}
+		if (propertyNames.has(property.name)) {
+			throw new Error(
+				`Data source "${dataSource.resourceId}" has duplicate property name "${property.name}"`,
+			);
+		}
+		propertyResourceIds.add(property.resourceId);
+		propertyNames.add(property.name);
+	}
+
+	return {
+		resourceId: dataSource.resourceId,
+		schema: dataSource.properties,
+		database: createAppsDatabase(dataSource.resourceId, dataSource),
+		addPage(pageArgs) {
+			return createPage(pageArgs, { type: "resourceId", resourceId: dataSource.resourceId });
+		},
+	};
+}

package/src/notion-as-code/date.ts

@@ -0,0 +1,91 @@
+/** Serialize Notion-as-Code date values for Apps property payloads. */
+export function date(startDate: string, endDate?: string): unknown[][] {
+	const start_date = parseIsoDate(startDate);
+	const end_date = endDate === undefined ? undefined : parseIsoDate(endDate);
+	if (end_date !== undefined && end_date < start_date) {
+		throw new Error("Date range end must be on or after start.");
+	}
+	const value =
+		end_date === undefined
+			? { type: "date", start_date }
+			: { type: "daterange", start_date, end_date };
+	return [["‣", [["d", value]]]];
+}
+
+/** Serialize Notion-as-Code datetime values for Apps property payloads. */
+export function datetime(value: { start: string; end?: string; timeZone?: string }): unknown[][] {
+	const timeZone = value.timeZone ?? "UTC";
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone }).format();
+	} catch {
+		throw new Error("Invalid time zone: " + timeZone);
+	}
+	const start = parseIsoDatetime(value.start);
+	const end = value.end === undefined ? undefined : parseIsoDatetime(value.end);
+	if (end !== undefined && end.date + "T" + end.time < start.date + "T" + start.time) {
+		throw new Error("Datetime range end must be on or after start.");
+	}
+	const dateValue =
+		end === undefined
+			? {
+					type: "datetime",
+					start_date: start.date,
+					start_time: start.time,
+					time_zone: timeZone,
+				}
+			: {
+					type: "datetimerange",
+					start_date: start.date,
+					start_time: start.time,
+					end_date: end.date,
+					end_time: end.time,
+					time_zone: timeZone,
+				};
+	return [["‣", [["d", dateValue]]]];
+}
+
+/** Validate a calendar date before serializing it. */
+function parseIsoDate(value: string): string {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+	if (match === null) {
+		throw new Error("Invalid ISO 8601 date: " + value + ". Expected format like 2024-01-15");
+	}
+	if (!isValidCalendarDate(match) || Number.isNaN(new Date(value).getTime())) {
+		throw new Error("Invalid date: " + value);
+	}
+	return value;
+}
+
+/** Validate and split an ISO datetime before serializing it. */
+function parseIsoDatetime(value: string): { date: string; time: string } {
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(value);
+	if (match === null) {
+		throw new Error(
+			"Invalid ISO 8601 datetime: " +
+				value +
+				". Expected format like 2024-01-15T10:30 or 2024-01-15T10:30:00Z",
+		);
+	}
+	if (
+		!isValidCalendarDate(match) ||
+		Number(match[4]) > 23 ||
+		Number(match[5]) > 59 ||
+		Number.isNaN(new Date(value).getTime())
+	) {
+		throw new Error("Invalid datetime: " + value);
+	}
+	return { date: value.slice(0, 10), time: value.slice(11, 16) };
+}
+
+/** Verify that parsed date components form a real calendar date. */
+function isValidCalendarDate(match: RegExpExecArray): boolean {
+	const year = Number(match[1] ?? "");
+	const month = Number(match[2] ?? "");
+	const day = Number(match[3] ?? "");
+	const date = new Date(Date.UTC(year, month - 1, day));
+	return (
+		date.getUTCFullYear() === year &&
+		date.getUTCMonth() === month - 1 &&
+		date.getUTCDate() === day
+	);
+}

package/src/notion-as-code/handles.ts

@@ -0,0 +1,36 @@
+import { customAgent } from "./custom-agent.js";
+import { database } from "./database.js";
+import { date, datetime } from "./date.js";
+import { page } from "./page.js";
+import { assertUserResourceId } from "./resource.js";
+import { teamspace } from "./teamspace.js";
+
+const notionAsCodeFacade = {
+	teamspace,
+	database,
+	page,
+	customAgent,
+	text: (value: string) => [[value]],
+	number: (value: number) => [[String(value)]],
+	date,
+	datetime,
+	select: (value: string) => value,
+	status: (value: string) => value,
+	multiSelect: (values: readonly string[]) => values.join(","),
+	checkbox: (value: boolean) => [[value ? "Yes" : "No"]],
+	url: (value: string) => [[value, [["a", value]]]],
+	email: (value: string) => [[value, [["a", `mailto:${value}`]]]],
+	phone: (value: string) => [[value]],
+	relation: (value: string | readonly string[]) => (Array.isArray(value) ? [...value] : value),
+	file: (resourceId: string) => {
+		assertUserResourceId(resourceId);
+		return { type: "file" as const, resourceId };
+	},
+};
+
+export type NotionAsCodeFacade = typeof notionAsCodeFacade;
+
+/** Create the runtime facade used to declare Notion-as-Code project metadata. */
+export function createNotion(): NotionAsCodeFacade {
+	return notionAsCodeFacade;
+}

package/src/notion-as-code/index.ts

@@ -0,0 +1,16 @@
+import { createNotion } from "./handles.js";
+
+export { APPS_RESERVED_RESOURCE_ID_PREFIX, APPS_WORKSPACE_RESOURCE_ID } from "./intents.js";
+export type { DataSourceDefinition, NotionAsCodeProperty, Parent } from "./intents.js";
+export type { CustomAgentArgs, CustomAgentHandle } from "./custom-agent.js";
+export type {
+	ChildDatabaseArgs,
+	DataSourceHandle,
+	DatabaseArgs,
+	DatabaseHandle,
+} from "./database.js";
+export type { ChildPageArgs, PageArgs, PageHandle } from "./page.js";
+export type { TeamspaceArgs, TeamspaceHandle } from "./teamspace.js";
+
+/** Experimental Notion-as-Code facade for Apps SDK project metadata. */
+export const notion = createNotion();

package/src/notion-as-code/intents.ts

@@ -0,0 +1,127 @@
+import type { CustomAgentArgs } from "./custom-agent.js";
+import type { DatabaseArgs } from "./database.js";
+import type { PageArgs } from "./page.js";
+import type { TeamspaceArgs } from "./teamspace.js";
+
+/** Apps-specific resource IDs used while declaring Notion-as-Code metadata. */
+/** Synthetic workspace parent for teamspaces declared by an Apps project. */
+export const APPS_WORKSPACE_RESOURCE_ID = "__notion_apps_workspace__";
+/** Reserved prefix for resource IDs owned by the Apps runtime. */
+export const APPS_RESERVED_RESOURCE_ID_PREFIX = "__notion_apps_";
+
+export type ResourceId = string;
+
+export type Parent = {
+	type: "resourceId";
+	resourceId: ResourceId;
+};
+
+export type NotionAsCodeIcon =
+	| { type: "emoji"; emoji: string }
+	| { type: "notion_icon"; description: string; color?: string }
+	| { type: "file"; resourceId: ResourceId };
+
+export type NotionAsCodeSelectColor =
+	| "default"
+	| "gray"
+	| "brown"
+	| "orange"
+	| "yellow"
+	| "green"
+	| "blue"
+	| "purple"
+	| "pink"
+	| "red";
+
+export type NotionAsCodeSelectOption = {
+	name: string;
+	color?: NotionAsCodeSelectColor;
+};
+
+export type NotionAsCodeStatusOption = NotionAsCodeSelectOption & {
+	default?: boolean;
+};
+
+type PropertyBase = {
+	resourceId: ResourceId;
+	name: string;
+	icon?: Extract<NotionAsCodeIcon, { type: "notion_icon" }>;
+	description?: string;
+};
+
+type UnsupportedProperty = PropertyBase & {
+	type:
+		| "relation"
+		| "formula"
+		| "rollup"
+		| "created_time"
+		| "last_edited_time"
+		| "created_by"
+		| "last_edited_by"
+		| "auto_increment_id"
+		| "person"
+		| "verification";
+	// TODO: Port configuration types for unsupported property kinds.
+	[key: string]: unknown;
+};
+
+export type NotionAsCodeProperty =
+	| (PropertyBase & { type: "title" })
+	| (PropertyBase & { type: "text" })
+	| (PropertyBase & { type: "number" })
+	| (PropertyBase & { type: "select"; options?: readonly NotionAsCodeSelectOption[] })
+	| (PropertyBase & { type: "multi_select"; options?: readonly NotionAsCodeSelectOption[] })
+	| {
+			resourceId: ResourceId;
+			name: string;
+			type: "status";
+			icon?: Extract<NotionAsCodeIcon, { type: "notion_icon" }>;
+			description?: string;
+			options: {
+				todo: readonly NotionAsCodeStatusOption[];
+				inProgress: readonly NotionAsCodeStatusOption[];
+				complete: readonly NotionAsCodeStatusOption[];
+			};
+	  }
+	| (PropertyBase & { type: "date" })
+	| (PropertyBase & { type: "checkbox" })
+	| (PropertyBase & { type: "url" })
+	| (PropertyBase & { type: "email" })
+	| (PropertyBase & { type: "phone_number" })
+	| (PropertyBase & { type: "file" })
+	| UnsupportedProperty;
+
+export type DataSourceDefinition<
+	Properties extends readonly NotionAsCodeProperty[] = readonly NotionAsCodeProperty[],
+> = {
+	resourceId: ResourceId;
+	name: string;
+	properties: Properties;
+	icon?: NotionAsCodeIcon;
+	// TODO: Port page layout types.
+	pageLayout?: unknown;
+};
+
+export type TeamspaceIntent = TeamspaceArgs & {
+	parent: Parent;
+};
+
+export type DatabaseIntent = DatabaseArgs & {
+	dataSources: readonly DataSourceDefinition[];
+};
+
+export type PageIntent = PageArgs;
+export type CustomAgentIntent = CustomAgentArgs;
+
+export type ViewIntent = {
+	databaseResourceId: ResourceId;
+	// TODO: Port view types.
+	view: unknown;
+};
+
+export type InfraAsCodeIntent =
+	| ({ type: "teamspace" } & TeamspaceIntent)
+	| ({ type: "database" } & DatabaseIntent)
+	| ({ type: "page" } & PageIntent)
+	| ({ type: "custom_agent" } & CustomAgentIntent)
+	| ({ type: "view" } & ViewIntent);

package/src/notion-as-code/page.ts

@@ -0,0 +1,61 @@
+import type {
+	DataSourceDefinition,
+	NotionAsCodeIcon,
+	PageIntent,
+	Parent,
+	ResourceId,
+} from "./intents.js";
+import { database, type ChildDatabaseArgs, type DatabaseHandle } from "./database.js";
+import { recordIntent } from "./recorder.js";
+import { assertParent, assertUserResourceId } from "./resource.js";
+
+export type PageArgs = {
+	resourceId: ResourceId;
+	parent: Parent;
+	icon?: NotionAsCodeIcon;
+	// TODO: Port cover types.
+	cover?: unknown;
+	// TODO: Port page property types.
+	properties?: Record<string, unknown>;
+	content?: string;
+	fullWidth?: boolean;
+};
+
+export type ChildPageArgs = Omit<PageArgs, "parent">;
+
+export type PageHandle = {
+	readonly resourceId: string;
+	addDatabase: <const DataSources extends readonly DataSourceDefinition[]>(
+		args: ChildDatabaseArgs<DataSources>,
+	) => DatabaseHandle<DataSources>;
+	addPage: (args: ChildPageArgs) => PageHandle;
+};
+
+/** Declare a top-level page. */
+export function page(args: PageArgs): PageHandle {
+	assertParent(args.parent);
+	return createPage(args, args.parent);
+}
+
+/** Record a page declaration beneath its parent resource. */
+export function createPage(args: ChildPageArgs | PageArgs, parent: Parent): PageHandle {
+	assertUserResourceId(args.resourceId);
+	recordIntent({
+		type: "page",
+		...args,
+		parent,
+	} satisfies { type: "page" } & PageIntent);
+
+	return {
+		resourceId: args.resourceId,
+		addDatabase(databaseArgs) {
+			return database({
+				...databaseArgs,
+				parent: { type: "resourceId", resourceId: args.resourceId },
+			});
+		},
+		addPage(pageArgs) {
+			return createPage(pageArgs, { type: "resourceId", resourceId: args.resourceId });
+		},
+	};
+}