@notionhq/apps 0.0.14 → 0.0.16

package/skills/workflow/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: workflow
+description: Build or review Notion App workflows for typed triggers, durable replay-safe steps, and idempotent effects.
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Workflow
+
+Use this skill to add or review a workflow in this template.
+
+## Build or change a workflow
+
+1. Read `AGENTS.md` and the existing files in `src/workflows/`.
+2. Inspect the installed workflow and trigger declarations.
+3. Choose the trigger, outcome, step boundaries, and required configuration.
+4. Create one camelCase file directly in `src/workflows/`.
+5. Default-export `workflow(...)` and use typed trigger creators.
+6. Put all non-deterministic work in awaited `context.step(...)` calls.
+7. Give each step a stable display name. For repeated steps, keep the name
+   constant and pass a stable, unique composite `key`, such as
+   `{ key: ["process-page", page.id] }`.
+8. Return JSON-safe values needed by later steps.
+9. Use the step `id` as an idempotency key when supported.
+10. Run `npm run check` and `npm run build`.
+
+Each direct `src/workflows/*.ts` file must default-export `workflow(...)`.
+The camelCase file name becomes its workflow key.
+Keep workflow-specific helpers in `src/workflows/lib/` and shared helpers in
+`src/lib/`; direct children of `src/workflows/` are discovered as workflows.
+
+For provider triggers, follow [trigger connection binding](../connections/SKILL.md#bind-triggers-to-connections).
+Use the typed trigger callback to check `connectionKey` against the declared
+provider connections.
+
+Use a step for every value that can change and every external effect: network
+and Notion API calls, mutable state reads, timestamps, random values, generated
+IDs, messages, creates, and updates. Keep deterministic transforms of the event
+and completed step results outside a step.
+
+Completed steps replay saved results. Do not rely on in-memory mutations inside
+a step. Return the values required by later code. Keep calls in a stable order
+and give every step a stable display name. The name is the replay key by
+default. For a repeated step, do not interpolate an item ID or loop index into
+the name; pass a stable composite key instead:
+
+```ts
+await context.step("Process page", { key: ["process-page", page.id] }, async ({ id }) =>
+	processPage(page, { idempotencyKey: id }),
+);
+```
+
+Keys must be stable across retries and unique within one workflow run.
+
+An external effect can succeed before its step result is saved. Pass the
+callback `id` as an idempotency key when supported; otherwise use a stable
+external ID, upsert, or duplicate check.
+
+Do not write credentials. Add only environment variable names and safe
+placeholders to `.env.example` when configuration is required. Return only
+JSON-serializable step values, throw on failed requests and missing required
+configuration, and do not log secrets or private payloads.
+
+## Resources created with the App
+
+Use [Notion as Code](../notion-as-code/SKILL.md) for pages and databases that
+should be created during deployment. Prefer it over equivalent manual setup
+or API calls that create the App's resources. Use runtime API calls for dynamic
+data changes, not as a substitute for supported Notion as Code setup.
+Keep declarations at module scope in
+an imported helper. For example, declare a guide page in `src/lib/resources.ts`:
+
+```ts
+import { page } from "@notionhq/apps";
+
+export const guide = page({
+	resourceId: "workflow-guide",
+	content: "# Workflow guide\nThis App runs a scheduled workflow.",
+});
+```
+
+Import the module from `src/workflows/sayHello.ts` so the build records it:
+
+```ts
+import "../lib/resources";
+import { workflow } from "@notionhq/apps";
+import { triggers } from "@notionhq/apps/triggers";
+
+export default workflow({
+	name: "Say Hello",
+	description: "Says hello on a recurring schedule.",
+	triggers: [triggers.scheduled()],
+	handler: async (_event, context) => {
+		await context.step("Say hello", () => {
+			console.log("Hello from your workflow!");
+		});
+	},
+});
+```
+
+The page is provisioned during deployment, not on every workflow run.
+Database declarations follow the same import pattern; see the
+[sync example](../sync/SKILL.md#choose-the-database-source) for using a Notion as Code
+data source in a sync. Notion as Code resource IDs are declaration identities, not live
+Notion UUIDs to pass to `context.notion`. Runtime API calls still belong in
+durable steps and need actual resolved Notion IDs.
+
+## Review a workflow
+
+Review every file in `src/workflows/` and the modules it calls. Report each
+finding with its file, line, impact, and fix. Treat these as errors:
+
+1. A workflow is not a direct file or does not default-export `workflow`.
+2. Trigger-specific event fields are used without type narrowing.
+3. Non-deterministic work occurs outside an awaited step.
+4. Step order or names can change between retries.
+5. A step result is not JSON-serializable, or later code needs an in-memory mutation.
+6. A retry-sensitive write lacks an idempotency key or duplicate guard.
+7. External failures are ignored, or credentials are hard-coded or logged.
+8. An explicit trigger connection key is undeclared, belongs to the wrong
+   provider, or repeats the same trigger-type/key pair.
+
+Run `npm run check` and `npm run build` when dependencies are installed.

package/src/cli/build.test.ts

@@ -2,9 +2,101 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, expectTypeOf, it } from "vitest";
 
 import { buildApp } from "./build.js";
+import {
+	notion,
+	type DataSourceHandle,
+	type SingleSourceDatabaseHandle,
+} from "../notion-as-code/index.js";
+import { finishMetadataRecording, startMetadataRecording } from "../notion-as-code/recorder.js";
+
+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",
+			name: "Issues",
+			properties: [
+				{ resourceId: "title", name: "Name", type: "title" },
+				{ resourceId: "count", name: "Count", type: "number" },
+			],
+		});
+		expectTypeOf(database).toExtend<
+			SingleSourceDatabaseHandle<typeof database.dataSource.schema>
+		>();
+		expectTypeOf(
+			database.dataSource.database.config.schema.Count.type,
+		).toEqualTypeOf<"number">();
+		database.dataSource.addPage({ resourceId: "issue" });
+		const shorthand = finishMetadataRecording(recorder).intents;
+
+		const explicitRecorder = startMetadataRecording();
+		const explicit = notion.database({
+			resourceId: "issues",
+			name: "Issues",
+			dataSources: [
+				{
+					resourceId: "issues-source",
+					name: "Issues",
+					properties: database.dataSource.schema,
+				},
+			],
+		});
+		explicit.dataSources["issues-source"].addPage({ resourceId: "issue" });
+		// @ts-expect-error Explicit databases do not guarantee a single source.
+		void explicit.dataSource;
+		expect(shorthand).toEqual(finishMetadataRecording(explicitRecorder).intents);
+		expect(database.dataSource.database.key).toBe("issues-source");
+		expect(shorthand[1]).toEqual({
+			type: "page",
+			resourceId: "issue",
+			parent: { type: "resourceId", resourceId: "issues-source" },
+		});
+	});
+
+	it("preserves parent binding and inferred source types through child helpers", () => {
+		const recorder = startMetadataRecording();
+		const page = notion.page({ resourceId: "page" });
+		const team = notion.teamspace({ resourceId: "team", name: "Team", accessLevel: "private" });
+		for (const parent of [page, team]) {
+			const database = parent.addDatabase({
+				resourceId: `${parent.resourceId}-db`,
+				name: "Child",
+				properties: [
+					{ resourceId: `${parent.resourceId}-title`, name: "Title", type: "title" },
+				],
+			});
+			expectTypeOf(database.dataSource).toExtend<
+				DataSourceHandle<typeof database.dataSource.schema>
+			>();
+			expectTypeOf(database.dataSource.schema[0].name).toEqualTypeOf<"Title">();
+		}
+		const intents = finishMetadataRecording(recorder).intents;
+		expect(
+			intents.filter((intent) => intent.type === "database").map((intent) => intent.parent),
+		).toEqual([
+			{ type: "resourceId", resourceId: "page" },
+			{ type: "resourceId", resourceId: "team" },
+		]);
+	});
+
+	it("rejects mixed forms before recording an intent", () => {
+		const recorder = startMetadataRecording();
+		const declareMixedDatabase = () => {
+			// @ts-expect-error The shorthand and explicit forms are mutually exclusive.
+			notion.database({
+				resourceId: "mixed",
+				name: "Mixed",
+				properties: [],
+				dataSources: [],
+			});
+		};
+		expect(declareMixedDatabase).toThrow();
+		expect(finishMetadataRecording(recorder).intents).toEqual([]);
+	});
+});
 
 const FIXTURES = fileURLToPath(new URL("../../test/fixtures/", import.meta.url));
 const EXAMPLES = fileURLToPath(new URL("../../examples/", import.meta.url));
@@ -54,9 +146,7 @@ describe("buildApp", () => {
 			},
 		]);
 		const worker = await fs.promises.readFile(bundlePath, "utf8");
-		expect(worker).not.toMatch(
-			/custom_block|createCustomBlock|react|createRoot|NotionCustomBlock/,
-		);
+		expect(worker).not.toMatch(/custom_block|customBlock|react|createRoot|NotionCustomBlock/);
 		expect(fs.existsSync(path.join(root, ".notion/blocks.js"))).toBe(false);
 	});
 	it("names the block file when path is missing", async () => {
@@ -66,7 +156,7 @@ describe("buildApp", () => {
 	});
 	it("rejects a block file that exports a different capability", async () => {
 		await expect(buildApp(fixture("custom-block-wrong-tag"))).rejects.toThrow(
-			/hello.ts.*createCustomBlock/,
+			/hello.ts.*customBlock/,
 		);
 	});
 
@@ -91,7 +181,7 @@ describe("buildApp", () => {
 					},
 				},
 				{
-					key: "homebase-meetings-source",
+					key: "homebase-meetings-db-source",
 					config: {
 						initialTitle: "Meetings",
 						schema: {
@@ -122,7 +212,7 @@ describe("buildApp", () => {
 					type: "sync",
 					key: "notionAsCodeIssues",
 					config: {
-						databaseKey: "homebase-meetings-source",
+						databaseKey: "homebase-meetings-db-source",
 						primaryKeyProperty: "Meeting ID",
 						mode: "incremental",
 						schedule: { type: "interval", intervalMs: 3_600_000 },

package/src/cli/emit-manifest.ts

@@ -233,7 +233,7 @@ export async function extractManifest(
 		if (!tagged || tagged._tag !== capability.tag) {
 			throw new Error(
 				`${capability.sourcePath}: default export is not a ${capability.type} — ` +
-					`files under this directory must default-export create${capability.type === "custom_block" ? "CustomBlock" : capitalize(capability.type)}(...)`,
+					`files under this directory must default-export ${capability.type === "custom_block" ? "customBlock" : capability.type}(...)`,
 			);
 		}
 
@@ -342,10 +342,6 @@ function getCapabilityRegistry(
 	return bundle.capabilities as Record<string, Record<string, unknown> | undefined>;
 }
 
-function capitalize(value: string): string {
-	return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
-}
-
 /**
  * Throw if `value` contains anything `JSON.stringify` would silently drop or
  * rewrite, so invalid manifest configuration fails during the build.

package/src/context.test.ts

@@ -0,0 +1,26 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createCapabilityContext } from "./context.js";
+
+afterEach(() => {
+	delete process.env.NOTION_API_TOKEN;
+	delete process.env.NOTION_WORKFLOW_STEP_DIRECTORY;
+});
+
+describe("createCapabilityContext", () => {
+	it("explains how to configure local Notion API access", () => {
+		const context = createCapabilityContext();
+
+		expect(() => context.notion.pages).toThrow(
+			"NOTION_API_TOKEN is not set. context.notion requires an API token when an app capability runs locally.",
+		);
+	});
+
+	it("explains how to grant deployed workflow access", () => {
+		process.env.NOTION_WORKFLOW_STEP_DIRECTORY = "/tmp/notion-run/steps";
+		const context = createCapabilityContext();
+
+		expect(() => context.notion.pages).toThrow(
+			"Notion API access is not configured for this deployed workflow. In Notion, open Developer Tools → Workers",
+		);
+	});
+});

package/src/context.ts

@@ -13,6 +13,14 @@ const LOCAL_FIX_STEPS =
 	"Deployed apps receive Notion API credentials automatically. Do not push NOTION_API_TOKEN.";
 
 function missingTokenMessage(): string {
+	if (process.env.NOTION_WORKFLOW_STEP_DIRECTORY) {
+		return (
+			"Notion API access is not configured for this deployed workflow. " +
+			"In Notion, open Developer Tools → Workers, select this workflow, and grant access to the pages or databases it uses. " +
+			"The runtime provides NOTION_API_TOKEN automatically after access is configured; do not set or push it yourself."
+		);
+	}
+
 	return (
 		"NOTION_API_TOKEN is not set. " +
 		"context.notion requires an API token when an app capability runs locally." +

package/src/custom-block.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { createCustomBlock } from "./custom-block.js";
+import { customBlock } from "./custom-block.js";
 
-describe("createCustomBlock", () => {
+describe("customBlock", () => {
 	it("supports static assets without a build command", () => {
-		expect(createCustomBlock({ path: "assets", static: true }).config.source).toEqual({
+		expect(customBlock({ path: "assets", static: true }).config.source).toEqual({
 			type: "static",
 			path: "assets",
 		});
@@ -11,7 +11,7 @@ describe("createCustomBlock", () => {
 	it.each(["//hello", "Hello", "-hello", "", "a".repeat(65)])(
 		"rejects invalid slash command %s",
 		(slashCommand) => {
-			expect(() => createCustomBlock({ path: "blocks/hello", slashCommand })).toThrow(
+			expect(() => customBlock({ path: "blocks/hello", slashCommand })).toThrow(
 				/slashCommand/,
 			);
 		},

package/src/custom-block.ts

@@ -10,9 +10,9 @@ export type CustomBlockOptions = {
 );
 
 /** Declare a browser project. Its filename under src/customBlocks supplies its key. */
-export function createCustomBlock(options: CustomBlockOptions) {
+export function customBlock(options: CustomBlockOptions) {
 	if (typeof options.path !== "string" || options.path.trim() === "") {
-		throw new Error("createCustomBlock requires a non-empty path relative to the app root");
+		throw new Error("customBlock requires a non-empty path relative to the app root");
 	}
 	const slashCommand = options.slashCommand?.replace(/^\//, "");
 	if (slashCommand !== undefined && !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(slashCommand)) {

package/src/index.ts

@@ -0,0 +1,7 @@
+export { customBlock } from "./custom-block.js";
+export { customAgent } from "./notion-as-code/custom-agent.js";
+export { database } from "./notion-as-code/database.js";
+export { page } from "./notion-as-code/page.js";
+export { teamspace } from "./notion-as-code/teamspace.js";
+export { sync } from "./sync.js";
+export { workflow } from "./workflow.js";

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

@@ -37,6 +37,19 @@ export type ChildDatabaseArgs<
 	DataSources extends readonly DataSourceDefinition[] = readonly DataSourceDefinition[],
 > = Omit<DatabaseArgs<DataSources>, "parent">;
 
+/** Single-source shorthand; the source ID is `${resourceId}-source`. */
+export type SingleSourceDatabaseArgs<
+	Properties extends readonly NotionAsCodeProperty[] = readonly NotionAsCodeProperty[],
+> = Omit<DatabaseArgs, "dataSources" | "name"> & {
+	name: string;
+	properties: Properties;
+	dataSources?: never;
+};
+
+export type ChildSingleSourceDatabaseArgs<
+	Properties extends readonly NotionAsCodeProperty[] = readonly NotionAsCodeProperty[],
+> = Omit<SingleSourceDatabaseArgs<Properties>, "parent">;
+
 /** Resolves one data source ID to the properties declared for it. */
 type DataSourcePropertiesForResourceId<
 	DataSources extends readonly DataSourceDefinition[],
@@ -71,11 +84,32 @@ export type DatabaseHandle<
 	addView: (view: unknown) => void;
 };
 
+/** A database whose sole data source is available without an ID lookup. */
+export type SingleSourceDatabaseHandle<
+	Properties extends readonly NotionAsCodeProperty[] = readonly NotionAsCodeProperty[],
+> = DatabaseHandle<readonly DataSourceDefinition<Properties>[]> & {
+	readonly dataSource: DataSourceHandle<Properties>;
+};
+
+export type ChildDatabaseFactory = {
+	<const Properties extends readonly NotionAsCodeProperty[]>(
+		args: ChildSingleSourceDatabaseArgs<Properties>,
+	): SingleSourceDatabaseHandle<Properties>;
+	<const DataSources extends readonly DataSourceDefinition[]>(
+		args: ChildDatabaseArgs<DataSources> & { properties?: never },
+	): DatabaseHandle<DataSources>;
+};
+
 /** Declare a database, defaulting to a private top-level database in the Apps workspace. */
+export function database<const Properties extends readonly NotionAsCodeProperty[]>(
+	args: SingleSourceDatabaseArgs<Properties>,
+): SingleSourceDatabaseHandle<Properties>;
 export function database<const DataSources extends readonly DataSourceDefinition[]>(
-	args: DatabaseArgs<DataSources>,
+	args: DatabaseArgs<DataSources> & { properties?: never },
 ): DatabaseHandle<DataSources>;
-export function database(args: DatabaseArgs): DatabaseHandle {
+export function database(
+	args: DatabaseArgs | SingleSourceDatabaseArgs,
+): DatabaseHandle | SingleSourceDatabaseHandle {
 	if (args.parent) {
 		assertParent(args.parent);
 	}
@@ -83,9 +117,45 @@ export function database(args: DatabaseArgs): DatabaseHandle {
 		type: "resourceId",
 		resourceId: APPS_WORKSPACE_RESOURCE_ID,
 	};
+	if ("properties" in args) {
+		if (args.dataSources !== undefined) {
+			throw new Error("Specify either properties or dataSources, not both");
+		}
+		const { properties, ...databaseArgs } = args;
+		const source: DataSourceDefinition = {
+			resourceId: `${args.resourceId}-source`,
+			name: args.name,
+			properties,
+		};
+		const handle = createDatabase({ ...databaseArgs, dataSources: [source] }, parent);
+		const dataSource = handle.dataSources[source.resourceId];
+		if (!dataSource) {
+			throw new Error(`Missing data source "${source.resourceId}"`);
+		}
+		return { ...handle, dataSource };
+	}
 	return createDatabase(args, parent);
 }
 
+/** Bind both database declaration forms to an existing parent. */
+export function createChildDatabase(parent: Parent): ChildDatabaseFactory {
+	function addDatabase<const Properties extends readonly NotionAsCodeProperty[]>(
+		args: ChildSingleSourceDatabaseArgs<Properties>,
+	): SingleSourceDatabaseHandle<Properties>;
+	function addDatabase<const DataSources extends readonly DataSourceDefinition[]>(
+		args: ChildDatabaseArgs<DataSources> & { properties?: never },
+	): DatabaseHandle<DataSources>;
+	function addDatabase(
+		args: ChildDatabaseArgs | ChildSingleSourceDatabaseArgs,
+	): DatabaseHandle | SingleSourceDatabaseHandle {
+		if ("properties" in args) {
+			return database({ ...args, parent });
+		}
+		return database({ ...args, parent });
+	}
+	return addDatabase;
+}
+
 /** Record a database declaration and create handles for each of its data sources. */
 export function createDatabase(args: DatabaseArgs, parent: Parent): DatabaseHandle {
 	assertUserResourceId(args.resourceId);

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

@@ -5,9 +5,13 @@ export type { DataSourceDefinition, NotionAsCodeProperty, Parent } from "./inten
 export type { CustomAgentArgs, CustomAgentHandle } from "./custom-agent.js";
 export type {
 	ChildDatabaseArgs,
+	ChildDatabaseFactory,
+	ChildSingleSourceDatabaseArgs,
 	DataSourceHandle,
 	DatabaseArgs,
 	DatabaseHandle,
+	SingleSourceDatabaseArgs,
+	SingleSourceDatabaseHandle,
 } from "./database.js";
 export type { ChildPageArgs, PageArgs, PageHandle } from "./page.js";
 export type { TeamspaceArgs, TeamspaceHandle } from "./teamspace.js";

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

@@ -1,11 +1,10 @@
 import {
 	APPS_WORKSPACE_RESOURCE_ID,
-	type DataSourceDefinition,
 	type PageIntent,
 	type Parent,
 	type ResourceId,
 } from "./intents.js";
-import { database, type ChildDatabaseArgs, type DatabaseHandle } from "./database.js";
+import { createChildDatabase, type ChildDatabaseFactory } from "./database.js";
 import { recordIntent } from "./recorder.js";
 import { assertParent, assertUserResourceId } from "./resource.js";
 
@@ -25,9 +24,7 @@ export type ChildPageArgs = Omit<PageArgs, "parent">;
 
 export type PageHandle = {
 	readonly resourceId: string;
-	addDatabase: <const DataSources extends readonly DataSourceDefinition[]>(
-		args: ChildDatabaseArgs<DataSources>,
-	) => DatabaseHandle<DataSources>;
+	addDatabase: ChildDatabaseFactory;
 	addPage: (args: ChildPageArgs) => PageHandle;
 };
 
@@ -54,12 +51,7 @@ export function createPage(args: ChildPageArgs | PageArgs, parent: Parent): Page
 
 	return {
 		resourceId: args.resourceId,
-		addDatabase(databaseArgs) {
-			return database({
-				...databaseArgs,
-				parent: { type: "resourceId", resourceId: args.resourceId },
-			});
-		},
+		addDatabase: createChildDatabase({ type: "resourceId", resourceId: args.resourceId }),
 		addPage(pageArgs) {
 			return createPage(pageArgs, { type: "resourceId", resourceId: args.resourceId });
 		},

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

@@ -1,11 +1,10 @@
 import {
 	APPS_WORKSPACE_RESOURCE_ID,
-	type DataSourceDefinition,
 	type NotionAsCodeIcon,
 	type ResourceId,
 	type TeamspaceIntent,
 } from "./intents.js";
-import { database, type ChildDatabaseArgs, type DatabaseHandle } from "./database.js";
+import { createChildDatabase, type ChildDatabaseFactory } from "./database.js";
 import { createPage, type ChildPageArgs, type PageHandle } from "./page.js";
 import { recordIntent } from "./recorder.js";
 import { assertUserResourceId } from "./resource.js";
@@ -20,9 +19,7 @@ export type TeamspaceArgs = {
 
 export type TeamspaceHandle = {
 	readonly resourceId: string;
-	addDatabase: <const DataSources extends readonly DataSourceDefinition[]>(
-		args: ChildDatabaseArgs<DataSources>,
-	) => DatabaseHandle<DataSources>;
+	addDatabase: ChildDatabaseFactory;
 	addPage: (args: ChildPageArgs) => PageHandle;
 };
 
@@ -37,12 +34,7 @@ export function teamspace(args: TeamspaceArgs): TeamspaceHandle {
 
 	return {
 		resourceId: args.resourceId,
-		addDatabase(databaseArgs) {
-			return database({
-				...databaseArgs,
-				parent: { type: "resourceId", resourceId: args.resourceId },
-			});
-		},
+		addDatabase: createChildDatabase({ type: "resourceId", resourceId: args.resourceId }),
 		addPage(pageArgs) {
 			return createPage(pageArgs, { type: "resourceId", resourceId: args.resourceId });
 		},

package/src/sync.ts

@@ -89,7 +89,7 @@ export type SyncConfiguration<
 };
 
 /** Configuration for a sync backed by a Notion-as-Code data source. */
-type DataSourceSyncConfiguration<
+export type DataSourceSyncConfiguration<
 	Properties extends readonly NotionAsCodeProperty[],
 	PrimaryKey extends KeyPropertyName<AppsSchemaForProperties<Properties>>,
 	State,
@@ -165,7 +165,7 @@ export function createSync<
 }
 
 /** Create a sync backed by a Notion-as-Code data source. */
-export function createDataSourceSync<
+export function sync<
 	const Properties extends readonly NotionAsCodeProperty[],
 	const PrimaryKey extends KeyPropertyName<AppsSchemaForProperties<Properties>>,
 	State = unknown,

package/src/workflow-connections-types.test.ts

@@ -1,9 +1,9 @@
 import { expectTypeOf, it } from "vitest";
 import { triggers } from "./triggers.generated.js";
-import { connections, createWorkflow, type WorkflowConnection } from "./workflow.js";
+import { connections, workflow, type WorkflowConnection } from "./workflow.js";
 
 it("infers only the declared provider clients", () => {
-	createWorkflow({
+	workflow({
 		name: "Calendar",
 		description: "Calendar only",
 		triggers: [triggers.notionPageCreated()],
@@ -14,7 +14,7 @@ it("infers only the declared provider clients", () => {
 		},
 	});
 	const requirements = [connections.calendar(), connections.slack({ key: "support" })];
-	createWorkflow({
+	workflow({
 		name: "Multiple providers",
 		description: "Preserves providers in a separately declared array",
 		triggers: [triggers.notionPageCreated()],
@@ -26,7 +26,7 @@ it("infers only the declared provider clients", () => {
 });
 
 it("exposes no providers for omitted or empty connections", () => {
-	createWorkflow({
+	workflow({
 		name: "No connections",
 		description: "Omitted",
 		triggers: [triggers.notionPageCreated()],
@@ -34,7 +34,7 @@ it("exposes no providers for omitted or empty connections", () => {
 			expectTypeOf<keyof typeof context.connections>().toEqualTypeOf<never>();
 		},
 	});
-	createWorkflow({
+	workflow({
 		name: "No connections",
 		description: "Empty",
 		triggers: [triggers.notionPageCreated()],
@@ -47,7 +47,7 @@ it("exposes no providers for omitted or empty connections", () => {
 
 it("preserves literal declarations checked with satisfies", () => {
 	const requirements = [connections.slack()] satisfies readonly WorkflowConnection[];
-	createWorkflow({
+	workflow({
 		name: "Slack",
 		description: "Slack only",
 		triggers: [triggers.notionPageCreated()],

package/src/workflow-types.test.ts

@@ -93,10 +93,10 @@ it("checks provider keys on callback arguments and returned triggers", () => {
 	const fixtures = new Map(
 		cases.map((testCase) => [
 			resolve("src", `__workflow_types_${testCase.name}.ts`),
-			`import { connections, createWorkflow } from "./workflow.js";
+			`import { connections, workflow } from "./workflow.js";
 		import { triggers as globalTriggers } from "./triggers.generated.js";
 		const support = connections.slack({ key: "support" });
-		createWorkflow({
+		workflow({
 			name: "Type check", description: "Type check",
 			${testCase.connections === undefined ? "" : `connections: ${testCase.connections},`}
 			triggers: ({ triggers }) => [${testCase.trigger}],