wrangler 2.5.0 → 2.6.0

package/src/__tests__/pubsub.test.ts

@@ -1,6 +1,7 @@
+import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type {
@@ -16,10 +17,6 @@ describe("wrangler", () => {
 	runInTempDir();
 	const std = mockConsoleMethods();
 
-	afterEach(() => {
-		unsetAllMocks();
-	});
-
 	describe("pubsub", () => {
 		describe("help menu", () => {
 			it("shows usage details", async () => {
@@ -83,15 +80,30 @@ describe("wrangler", () => {
 			describe("create", () => {
 				function mockCreateRequest(expectedNamespaceName: string) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces",
-						"POST",
-						([_url, accountId], { body }) => {
-							expect(accountId).toEqual("some-account-id");
-							const namespaceName = JSON.parse(body as string).name;
-							expect(namespaceName).toEqual(expectedNamespaceName);
-							requests.count += 1;
-						}
+					msw.use(
+						rest.post(
+							"*/accounts/:accountId/pubsub/namespaces",
+							async (req, res, ctx) => {
+								expect(req.params.accountId).toEqual("some-account-id");
+								const namespace = await req.json();
+								expect(namespace.name).toEqual(expectedNamespaceName);
+								requests.count++;
+								return res.once(
+									ctx.status(200),
+									ctx.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											id: "some-namespace-id",
+											name: namespace.name,
+											created_at: "3005-01-01T00:00:00.000000Z",
+											updated_at: "3005-01-01T00:00:00.000000Z",
+										},
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -107,14 +119,24 @@ describe("wrangler", () => {
 			describe("list", () => {
 				function mockListRequest(namespaces: PubSubNamespace[]) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces",
-						([_url, accountId], init) => {
-							requests.count++;
-							expect(accountId).toEqual("some-account-id");
-							expect(init).toEqual({});
-							return { namespaces };
-						}
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/pubsub/namespaces",
+							async (req, res, ctx) => {
+								requests.count++;
+								expect(req.params.accountId).toEqual("some-account-id");
+
+								return res.once(
+									ctx.status(200),
+									ctx.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: namespaces,
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -128,7 +150,12 @@ describe("wrangler", () => {
 					await runWrangler("pubsub namespace list");
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(`
+				"[
+				  { name: 'namespace-1', created_on: '01-01-2001' },
+				  { name: 'namespace-2', created_on: '01-01-2001' }
+				]"
+			`);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -174,16 +201,29 @@ describe("wrangler", () => {
 			describe("create", () => {
 				function mockCreateRequest(expectedBrokerName: string) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
-						"POST",
-						([_url, accountId, namespaceName], { body }) => {
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							const brokerName = JSON.parse(body as string).name;
-							expect(brokerName).toEqual(expectedBrokerName);
-							requests.count += 1;
-						}
+					msw.use(
+						rest.post(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
+							async (req, res, ctx) => {
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								const broker = await req.json();
+								expect(broker.name).toEqual(expectedBrokerName);
+								requests.count++;
+								return res.once(
+									ctx.status(200),
+									ctx.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											name: expectedBrokerName,
+											created_on: "01-01-2001",
+										},
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -194,7 +234,10 @@ describe("wrangler", () => {
 						"pubsub broker create my-broker --namespace=some-namespace"
 					);
 
-					// TODO: check returned object
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					expect(std.out).toMatchInlineSnapshot(
+						`"{ name: 'my-broker', created_on: '01-01-2001' }"`
+					);
 					expect(requests.count).toEqual(1);
 				});
 
@@ -215,21 +258,34 @@ describe("wrangler", () => {
 					expectedOnPublishConfig: PubSubBrokerOnPublish
 				) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
-						"PATCH",
-						([_url, accountId, namespaceName, brokerName], { body }) => {
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							expect(brokerName).toEqual(expectedBrokerName);
-
-							const patchBody: PubSubBrokerUpdate = JSON.parse(body as string);
-							expect(patchBody.expiration).toEqual(expectedExpiration);
-							expect(patchBody.description).toEqual(expectedDescription);
-							expect(patchBody.on_publish).toEqual(expectedOnPublishConfig);
-
-							requests.count += 1;
-						}
+					msw.use(
+						rest.patch(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
+							async (req, res, cxt) => {
+								requests.count += 1;
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								expect(req.params.brokerName).toEqual(expectedBrokerName);
+
+								const patchBody: PubSubBrokerUpdate = await req.json();
+
+								expect(patchBody.expiration).toEqual(expectedExpiration);
+								expect(patchBody.description).toEqual(expectedDescription);
+								expect(patchBody.on_publish).toEqual(expectedOnPublishConfig);
+								return res.once(
+									cxt.status(200),
+									cxt.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											name: expectedBrokerName,
+											created_on: "01-01-2001",
+										},
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -249,7 +305,10 @@ describe("wrangler", () => {
 					);
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(`
+				"{ name: 'my-broker', created_on: '01-01-2001' }
+				Successfully updated Pub/Sub Broker my-broker"
+			`);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -257,15 +316,24 @@ describe("wrangler", () => {
 			describe("list", () => {
 				function mockListRequest(brokers: PubSubBroker[]) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
-						([_url, accountId, namespaceName], init) => {
-							requests.count++;
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							expect(init).toEqual({});
-							return { brokers };
-						}
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
+							async (req, res, cxt) => {
+								requests.count++;
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								return res.once(
+									cxt.status(200),
+									cxt.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: brokers,
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -279,7 +347,12 @@ describe("wrangler", () => {
 					await runWrangler("pubsub broker list --namespace=some-namespace");
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(`
+				"[
+				  { name: 'broker-1', created_on: '01-01-2001' },
+				  { name: 'broker-2', created_on: '01-01-2001' }
+				]"
+			`);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -287,15 +360,25 @@ describe("wrangler", () => {
 			describe("describe", () => {
 				function mockGetRequest(broker: PubSubBroker) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
-						([_url, accountId, namespaceName, brokerName]) => {
-							requests.count++;
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							expect(brokerName).toEqual(broker.name);
-							return { result: broker };
-						}
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
+							(req, res, cxt) => {
+								requests.count++;
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								expect(req.params.brokerName).toEqual(broker.name);
+								return res.once(
+									cxt.status(200),
+									cxt.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: broker,
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -307,7 +390,9 @@ describe("wrangler", () => {
 					);
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(
+						`"{ id: '1234', name: 'my-broker' }"`
+					);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -315,14 +400,28 @@ describe("wrangler", () => {
 			describe("issue", () => {
 				function mockIssueRequest(expectedBrokerName: string) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/credentials",
-						([_url, accountId, namespaceName, brokerName]) => {
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							expect(brokerName).toEqual(expectedBrokerName);
-							requests.count += 1;
-						}
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/credentials",
+							(req, res, cxt) => {
+								requests.count++;
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								expect(req.params.brokerName).toEqual(expectedBrokerName);
+								return res.once(
+									cxt.status(200),
+									cxt.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											"MOCK-89T6DXG3SVG1WQRA": `<base-64-encoded-JWT>`,
+											"MOCK-393REE4WRRE4NHAV96": `<base-64-encoded-JWT>`,
+										},
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -334,7 +433,13 @@ describe("wrangler", () => {
 					);
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(`
+				"🔑 Issuing credential(s) for my-broker.some-namespace...
+				{
+				  'MOCK-89T6DXG3SVG1WQRA': '<base-64-encoded-JWT>',
+				  'MOCK-393REE4WRRE4NHAV96': '<base-64-encoded-JWT>'
+				}"
+			`);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -342,14 +447,27 @@ describe("wrangler", () => {
 			describe("public-keys", () => {
 				function mockIssueRequest(expectedBrokerName: string) {
 					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/publickeys",
-						([_url, accountId, namespaceName, brokerName]) => {
-							expect(accountId).toEqual("some-account-id");
-							expect(namespaceName).toEqual("some-namespace");
-							expect(brokerName).toEqual(expectedBrokerName);
-							requests.count += 1;
-						}
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/publickeys",
+							(req, res, cxt) => {
+								requests.count++;
+								expect(req.params.accountId).toEqual("some-account-id");
+								expect(req.params.namespaceName).toEqual("some-namespace");
+								expect(req.params.brokerName).toEqual(expectedBrokerName);
+								return res.once(
+									cxt.status(200),
+									cxt.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											public_keys: "Mock-Public-Key",
+										},
+									})
+								);
+							}
+						)
 					);
 					return requests;
 				}
@@ -361,7 +479,9 @@ describe("wrangler", () => {
 					);
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
-					// TODO(elithrar): check returned object
+					expect(std.out).toMatchInlineSnapshot(
+						`"{ public_keys: 'Mock-Public-Key' }"`
+					);
 					expect(requests.count).toEqual(1);
 				});
 			});

package/src/__tests__/tail.test.ts

@@ -694,7 +694,7 @@ function mockCreateTailRequest(
 				if (!legacyEnv) {
 					expect(req.params.envName).toEqual(env);
 				}
-				return res(
+				return res.once(
 					ctx.status(200),
 					ctx.json({
 						success: true,

package/src/__tests__/type-generation.test.ts

@@ -52,6 +52,12 @@ const bindingsConfigMock: Partial<Config> = {
 		},
 	],
 	services: [{ binding: "SERVICE_BINDING", service: "SERVICE_NAME" }],
+	analytics_engine_datasets: [
+		{
+			binding: "AE_DATASET_BINDING",
+			dataset: "AE_DATASET_TEST",
+		},
+	],
 	dispatch_namespaces: [
 		{ binding: "NAMESPACE_BINDING", namespace: "NAMESPACE_ID" },
 	],
@@ -116,6 +122,7 @@ describe("generateTypes()", () => {
 			R2_BUCKET_BINDING: R2Bucket;
 			D1_TESTING_SOMETHING: D1Database;
 			SERVICE_BINDING: Fetcher;
+			AE_DATASET_BINDING: AnalyticsEngineDataset;
 			NAMESPACE_BINDING: any;
 			LOGFWDR_SCHEMA: any;
 			SOME_DATA_BLOB1: ArrayBuffer;

package/src/config/environment.ts

@@ -439,6 +439,22 @@ interface EnvironmentNonInheritable {
 		  }[]
 		| undefined;
 
+	/**
+	 * Specifies analytics engine datasets that are bound to this Worker environment.
+	 *
+	 * NOTE: This field is not automatically inherited from the top level environment,
+	 * and so must be specified in every named environment.
+	 *
+	 * @default `[]`
+	 * @nonInheritable
+	 */
+	analytics_engine_datasets: {
+		/** The binding name used to refer to the dataset in the worker. */
+		binding: string;
+		/** The name of this dataset to write to. */
+		dataset?: string;
+	}[];
+
 	/**
 	 * "Unsafe" tables for features that aren't directly supported by wrangler.
 	 *

package/src/config/index.ts

@@ -93,6 +93,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		r2_buckets,
 		logfwdr,
 		services,
+		analytics_engine_datasets,
 		text_blobs,
 		unsafe,
 		vars,
@@ -159,14 +160,21 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 	if (d1_databases !== undefined && d1_databases.length > 0) {
 		output.push({
 			type: "D1 Databases",
-			entries: d1_databases.map(({ binding, database_name, database_id }) => {
-				return {
-					key: removeD1BetaPrefix(binding),
-					value: database_name
-						? `${database_name} (${database_id})`
-						: database_id,
-				};
-			}),
+			entries: d1_databases.map(
+				({ binding, database_name, database_id, preview_database_id }) => {
+					let databaseValue = `${database_id}`;
+					if (database_name) {
+						databaseValue = `${database_name} (${database_id})`;
+					}
+					if (preview_database_id) {
+						databaseValue += `, Preview: (${preview_database_id})`;
+					}
+					return {
+						key: removeD1BetaPrefix(binding),
+						value: databaseValue,
+					};
+				}
+			),
 		});
 	}
 
@@ -211,6 +219,21 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (
+		analytics_engine_datasets !== undefined &&
+		analytics_engine_datasets.length > 0
+	) {
+		output.push({
+			type: "Analytics Engine Datasets",
+			entries: analytics_engine_datasets.map(({ binding, dataset }) => {
+				return {
+					key: binding,
+					value: dataset ?? binding,
+				};
+			}),
+		});
+	}
+
 	if (text_blobs !== undefined && Object.keys(text_blobs).length > 0) {
 		output.push({
 			type: "Text Blobs",

package/src/config/validation.ts

@@ -1115,6 +1115,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateServiceBinding),
 			[]
 		),
+		analytics_engine_datasets: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"analytics_engine_datasets",
+			validateBindingArray(envName, validateAnalyticsEngineBinding),
+			[]
+		),
 		dispatch_namespaces: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1834,6 +1844,7 @@ const validateBindingsHaveUniqueNames = (
 		durable_objects,
 		kv_namespaces,
 		r2_buckets,
+		analytics_engine_datasets,
 		text_blobs,
 		unsafe,
 		vars,
@@ -1848,6 +1859,7 @@ const validateBindingsHaveUniqueNames = (
 		"Durable Object": getBindingNames(durable_objects),
 		"KV Namespace": getBindingNames(kv_namespaces),
 		"R2 Bucket": getBindingNames(r2_buckets),
+		"Analytics Engine Dataset": getBindingNames(analytics_engine_datasets),
 		"Text Blob": getBindingNames(text_blobs),
 		Unsafe: getBindingNames(unsafe),
 		"Environment Variable": getBindingNames(vars),
@@ -1956,6 +1968,43 @@ const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateAnalyticsEngineBinding: ValidatorFn = (
+	diagnostics,
+	field,
+	value
+) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"analytics_engine" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// Service bindings must have a binding and optional dataset.
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		!isOptionalProperty(value, "dataset", "string") ||
+		(value as { dataset: string }).dataset?.length === 0
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "dataset" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateWorkerNamespaceBinding: ValidatorFn = (
 	diagnostics,
 	field,

package/src/create-worker-upload-form.ts

@@ -43,6 +43,7 @@ type WorkerMetadataBinding =
 	| { type: "r2_bucket"; name: string; bucket_name: string }
 	| { type: "d1"; name: string; id: string; internalEnv?: string }
 	| { type: "service"; name: string; service: string; environment?: string }
+	| { type: "analytics_engine"; name: string; dataset?: string }
 	| { type: "namespace"; name: string; namespace: string }
 	| {
 			type: "logfwdr";
@@ -149,6 +150,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "analytics_engine",
+			dataset,
+		});
+	});
+
 	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
 		metadataBindings.push({
 			name: binding,