@notionhq/apps 0.0.16 → 0.0.17

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/triggers.generated.ts

@@ -1,7 +1,7 @@
 // Generated by scripts/generate-triggers.ts — do not edit by hand.
 // Regenerate with: pnpm run generate
 
-import type { WorkflowConnection, WorkflowConnectionKeys } from "./connections.js";
+import type { WorkflowConnectionDeclarations, WorkflowConnectionKeys } from "./connections.js";
 
 import type {
 	CalendarEventCanceledEvent,
@@ -438,7 +438,7 @@ export const triggers = {
 } as const;
 
 /** Trigger creators restricted to the workflow's declared provider keys. */
-export type WorkflowTriggerCreators<TConnections extends readonly WorkflowConnection[]> = {
+export type WorkflowTriggerCreators<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">>;
@@ -463,7 +463,7 @@ export type WorkflowTriggerCreators<TConnections extends readonly WorkflowConnec
 };
 
 /** Triggers whose connection keys belong to the declared provider. */
-export type WorkflowTriggerForConnections<TConnections extends readonly WorkflowConnection[]> =
+export type WorkflowTriggerForConnections<TConnections extends WorkflowConnectionDeclarations> =
 	| SlackMessageTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>
@@ -487,7 +487,7 @@ export type WorkflowTriggerForConnections<TConnections extends readonly Workflow
 	| RecurrenceTrigger;
 
 /** @internal */
-export function createWorkflowTriggers<TConnections extends readonly WorkflowConnection[]>(): WorkflowTriggerCreators<TConnections> {
+export function createWorkflowTriggers<TConnections extends WorkflowConnectionDeclarations>(): WorkflowTriggerCreators<TConnections> {
 	return triggers;
 }
 

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

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

package/src/workflow-types.test.ts

@@ -7,44 +7,44 @@ it("checks provider keys on callback arguments and returned triggers", () => {
 		{
 			name: "valid",
 			valid: true,
-			connections: '[connections.slack({ key: "support" }), connections.calendar()]',
+			connections: "{ support: connections.slack(), calendar: connections.calendar() }",
 			trigger:
 				'triggers.slackMessage({ connectionKey: "support" }), triggers.calendarEventCreated({ connectionKey: "calendar" })',
 		},
 		{
 			name: "default",
 			valid: true,
-			connections: "[connections.slack()]",
+			connections: "{ slack: connections.slack() }",
 			trigger: 'triggers.slackMessage({ connectionKey: "slack" })',
 		},
 		{
 			name: "unbound",
 			valid: true,
-			connections: "[]",
+			connections: "{}",
 			trigger: "triggers.slackMessage(), triggers.notionPageCreated()",
 		},
 		{
 			name: "global_valid",
 			valid: true,
-			connections: '[connections.slack({ key: "support" })]',
+			connections: "{ support: connections.slack() }",
 			trigger: 'globalTriggers.slackMessage({ connectionKey: "support" })',
 		},
 		{
 			name: "undeclared",
 			valid: false,
-			connections: '[connections.slack({ key: "support" })]',
+			connections: "{ support: connections.slack() }",
 			trigger: 'triggers.slackMessage({ connectionKey: "typo" })',
 		},
 		{
 			name: "wrong_provider",
 			valid: false,
-			connections: '[connections.calendar({ key: "support" })]',
+			connections: "{ support: connections.calendar() }",
 			trigger: 'triggers.slackMessage({ connectionKey: "support" })',
 		},
 		{
 			name: "custom_not_default",
 			valid: false,
-			connections: '[connections.slack({ key: "support" })]',
+			connections: "{ support: connections.slack() }",
 			trigger: 'triggers.slackMessage({ connectionKey: "slack" })',
 		},
 		{
@@ -56,51 +56,123 @@ it("checks provider keys on callback arguments and returned triggers", () => {
 		{
 			name: "global_invalid",
 			valid: false,
-			connections: '[connections.calendar({ key: "support" })]',
+			connections: "{ support: connections.calendar() }",
 			trigger: 'globalTriggers.slackMessage({ connectionKey: "support" })',
 		},
 		{
 			name: "literal_invalid",
 			valid: false,
-			connections: '[connections.calendar({ key: "support" })]',
+			connections: "{ support: connections.calendar() }",
 			trigger: '{ type: "slack.message", connectionKey: "support" }',
 		},
 		{
-			name: "generic_without_key",
+			name: "old_key_option",
 			valid: false,
-			connections: '[connections.slack<"support">()]',
+			connections: '{ support: connections.slack({ key: "support" }) }',
 			trigger: 'triggers.slackMessage({ connectionKey: "support" })',
 		},
 		{
 			name: "literal_default",
 			valid: true,
-			connections: '[{ type: "slack" }]',
+			connections: '{ slack: { type: "slack" } }',
 			trigger: 'triggers.slackMessage({ connectionKey: "slack" })',
 		},
 		{
 			name: "saved",
 			valid: true,
-			connections: "[support]",
+			connections: "{ support }",
 			trigger: 'triggers.slackMessage({ connectionKey: "support" })',
 		},
 		{
 			name: "saved_invalid",
 			valid: false,
-			connections: "[support]",
+			connections: "{ support }",
 			trigger: 'triggers.slackMessage({ connectionKey: "slack" })',
 		},
+		{
+			name: "old_array",
+			valid: false,
+			connections: "[connections.slack()]",
+			trigger: "triggers.slackMessage()",
+		},
+		{
+			name: "two_slack",
+			valid: true,
+			connections: "{ support: connections.slack(), team: connections.slack() }",
+			trigger: 'triggers.slackMessage({ connectionKey: "team" })',
+		},
+
+		{
+			name: "keyed_clients",
+			valid: true,
+			connections:
+				"{ support: connections.slack(), team: connections.slack(), work: connections.calendar() }",
+			trigger: "triggers.notionPageCreated()",
+			handler:
+				'(_event, ctx) => { ctx.connections.support.findUserByEmail({ email: "a@example.com" }); ctx.connections.team.findUserByEmail({ email: "b@example.com" }); ctx.connections.work.listCalendars({}); }',
+		},
+		{
+			name: "wrong_client_method",
+			valid: false,
+			connections: "{ support: connections.slack() }",
+			trigger: "triggers.notionPageCreated()",
+			handler: "(_event, ctx) => { ctx.connections.support.listCalendars({}); }",
+		},
+		{
+			name: "undeclared_client",
+			valid: false,
+			connections: "{ support: connections.slack() }",
+			trigger: "triggers.notionPageCreated()",
+			handler:
+				'(_event, ctx) => { ctx.connections.slack.findUserByEmail({ email: "a@example.com" }); }',
+		},
+		{
+			name: "old_provider_call",
+			valid: false,
+			connections: "{ support: connections.slack() }",
+			trigger: "triggers.notionPageCreated()",
+			handler: '(_event, ctx) => { ctx.connections.support("support"); }',
+		},
+		{
+			name: "oauth_keyed_client",
+			valid: true,
+			connections: "{ github: connections.oauth(oauthConfig), support: connections.slack() }",
+			trigger: 'triggers.slackMessage({ connectionKey: "support" })',
+			handler:
+				"async (_event, ctx) => { const token: string = await ctx.connections.github.accessToken(); void token; }",
+		},
+		{
+			name: "oauth_wrong_trigger",
+			valid: false,
+			connections: "{ github: connections.oauth(oauthConfig) }",
+			trigger: 'triggers.slackMessage({ connectionKey: "github" })',
+		},
+		{
+			name: "oauth_old_key_option",
+			valid: false,
+			connections: '{ github: connections.oauth({ ...oauthConfig, key: "github" }) }',
+			trigger: "triggers.notionPageCreated()",
+		},
+		{
+			name: "oauth_old_provider_call",
+			valid: false,
+			connections: "{ github: connections.oauth(oauthConfig) }",
+			trigger: "triggers.notionPageCreated()",
+			handler: '(_event, ctx) => { ctx.connections.oauth("github"); }',
+		},
 	];
 	const fixtures = new Map(
 		cases.map((testCase) => [
 			resolve("src", `__workflow_types_${testCase.name}.ts`),
 			`import { connections, workflow } from "./workflow.js";
 		import { triggers as globalTriggers } from "./triggers.generated.js";
-		const support = connections.slack({ key: "support" });
+		const support = connections.slack();
+		const oauthConfig = { authorizationEndpoint: "https://example.com/authorize", tokenEndpoint: "https://example.com/token", clientId: "client", clientSecretEnv: "CLIENT_SECRET", scope: "read" };
 		workflow({
 			name: "Type check", description: "Type check",
 			${testCase.connections === undefined ? "" : `connections: ${testCase.connections},`}
 			triggers: ({ triggers }) => [${testCase.trigger}],
-			handler: () => {},
+			handler: ${testCase.handler ?? "() => {}"},
 		});`,
 		]),
 	);

package/src/workflow.test.ts

@@ -37,8 +37,8 @@ afterEach(async () => {
 
 const event = { type: "notion.page.created" } as NotionPageCreatedEvent;
 
-async function createWorkflowContext(): Promise<WorkflowContext<readonly []>> {
-	let context: WorkflowContext<readonly []> | undefined;
+async function createWorkflowContext(): Promise<WorkflowContext<Record<never, never>>> {
+	let context: WorkflowContext<Record<never, never>> | undefined;
 	const definition = workflow({
 		name: "Test workflow",
 		description: "Captures its workflow context",
@@ -743,23 +743,54 @@ describe("workflow", () => {
 			name: "Schedule Follow-up",
 			description: "Schedules a follow-up after a page is created",
 			triggers: [triggers.notionPageCreated()],
-			connections: [connections.calendar()],
+			connections: { calendar: connections.calendar() },
 			handler: () => {},
 		});
 
-		expect(definition.config.connections).toEqual([{ type: "calendar" }]);
+		expect(definition.config.connections).toEqual([{ type: "calendar", key: "calendar" }]);
 	});
 
-	it("rejects duplicate connection requirements", () => {
+	it("keeps declaration keys stable after the input object changes", async () => {
+		const declarations = { support: connections.slack() };
+		const seen: string[][] = [];
+		const definition = workflow({
+			name: "Snapshot connections",
+			description: "Captures declared keys",
+			connections: declarations,
+			triggers: [triggers.notionPageCreated()],
+			handler(_event, context) {
+				seen.push(Object.keys(context.connections));
+			},
+		});
+		Object.assign(declarations, { support: connections.calendar(), team: connections.slack() });
+		expect(definition.config.connections).toEqual([{ type: "slack", key: "support" }]);
+		await definition.handler(event, { concreteOutput: true });
+		expect(seen).toEqual([["support"]]);
+	});
+	it("rejects inherited declaration objects before cloning", () => {
+		const declarations = { support: connections.slack() };
+		Object.setPrototypeOf(declarations, { extra: connections.calendar() });
+		expect(() =>
+			workflow({
+				name: "Inherited keys",
+				description: "Reject prototype declarations",
+				connections: declarations,
+				triggers: [triggers.notionPageCreated()],
+				handler() {},
+			}),
+		).toThrow("only own");
+	});
+
+	it("rejects invalid connection property names", () => {
 		expect(() =>
 			workflow({
 				name: "Schedule Follow-up",
 				description: "Schedules a follow-up after a page is created",
 				triggers: [triggers.notionPageCreated()],
-				connections: [connections.calendar(), connections.calendar()],
+				connections: { "bad/key": connections.calendar() },
 				handler: () => {},
 			}),
-		).toThrowError("Duplicate workflow connection: calendar");
+		).toThrowError("Invalid workflow connection key: bad/key");
 	});
 
 	it("writes a success envelope after the handler runs", async () => {
@@ -839,7 +870,7 @@ describe("connection-bound triggers", () => {
 		const definition = workflow({
 			name: "Typed triggers",
 			description: "Uses only declared provider keys",
-			connections: [connections.slack({ key: "support" }), connections.calendar()],
+			connections: { support: connections.slack(), calendar: connections.calendar() },
 			triggers: ({ triggers }) => {
 				calls += 1;
 				expectTypeOf(triggers.slackMessage)
@@ -861,7 +892,7 @@ describe("connection-bound triggers", () => {
 					"slack.message" | "calendar.event.created"
 				>();
 				expectTypeOf<keyof typeof context.connections>().toEqualTypeOf<
-					"slack" | "calendar"
+					"support" | "calendar"
 				>();
 			},
 		});
@@ -876,7 +907,7 @@ describe("connection-bound triggers", () => {
 		const definition = workflow({
 			name: "Support",
 			description: "Watch support messages",
-			connections: [connections.slack({ key: "support" })],
+			connections: { support: connections.slack() },
 			triggers: [triggers.slackMessage({ connectionKey: "support" })],
 			handler(event) {
 				expectTypeOf(event.type).toEqualTypeOf<"slack.message">();
@@ -887,9 +918,9 @@ describe("connection-bound triggers", () => {
 		]);
 	});
 	it.each([
-		{ requirements: [] },
-		{ requirements: [connections.calendar({ key: "support" })] },
-		{ requirements: [connections.slack({ key: "other" })] },
+		{ requirements: {} },
+		{ requirements: { support: connections.calendar() } },
+		{ requirements: { other: connections.slack() } },
 	])("rejects missing or incompatible declarations: %j", ({ requirements }) => {
 		expect(() =>
 			workflow({
@@ -905,10 +936,7 @@ describe("connection-bound triggers", () => {
 		const configuration = {
 			name: "Support",
 			description: "",
-			connections: [
-				connections.slack({ key: "support" }),
-				connections.slack({ key: "internal" }),
-			],
+			connections: { support: connections.slack(), internal: connections.slack() },
 			handler() {},
 		};
 		expect(() =>