wrangler 0.0.0-e64812e → 0.0.0-e7a0cd5b

package/src/queues/cli/commands/consumer/remove.ts

@@ -0,0 +1,38 @@
+import { type Argv } from "yargs";
+import { readConfig } from "../../../../config";
+import { logger } from "../../../../logger";
+import { deleteConsumer } from "../../../client";
+import type { CommonYargsOptions } from "../../../../yargs-types";
+
+type Args = CommonYargsOptions & {
+	config?: string;
+	["queue-name"]: string;
+	["script-name"]: string;
+};
+
+export function options(yargs: Argv<CommonYargsOptions>): Argv<Args> {
+	return yargs
+		.positional("queue-name", {
+			type: "string",
+			demandOption: true,
+			description: "Name of the queue to configure",
+		})
+		.positional("script-name", {
+			type: "string",
+			demandOption: true,
+			description: "Name of the consumer script",
+		});
+}
+
+export async function handler(args: Args) {
+	const config = readConfig(args.config, args);
+
+	logger.log(`Removing consumer from queue ${args["queue-name"]}.`);
+	await deleteConsumer(
+		config,
+		args["queue-name"],
+		args["script-name"],
+		args.env
+	);
+	logger.log(`Removed consumer from queue ${args["queue-name"]}.`);
+}

package/src/queues/cli/commands/create.ts

@@ -0,0 +1,25 @@
+import { type Argv } from "yargs";
+import { readConfig } from "../../../config";
+import { logger } from "../../../logger";
+import { createQueue } from "../../client";
+
+interface Args {
+	config?: string;
+	name: string;
+}
+
+export function options(yargs: Argv): Argv<Args> {
+	return yargs.positional("name", {
+		type: "string",
+		demandOption: true,
+		description: "The name of the queue",
+	});
+}
+
+export async function handler(args: Args) {
+	const config = readConfig(args.config, args);
+
+	logger.log(`Creating queue ${args.name}.`);
+	await createQueue(config, { queue_name: args.name });
+	logger.log(`Created queue ${args.name}.`);
+}

package/src/queues/cli/commands/delete.ts

@@ -0,0 +1,26 @@
+import { type Argv } from "yargs";
+import { readConfig } from "../../../config";
+import { logger } from "../../../logger";
+import { deleteQueue } from "../../client";
+
+interface Args {
+	config?: string;
+	name: string;
+}
+
+export function options(yargs: Argv): Argv<Args> {
+	// TODO(soon) --force option
+	return yargs.positional("name", {
+		type: "string",
+		demandOption: true,
+		description: "The name of the queue",
+	});
+}
+
+export async function handler(args: Args) {
+	const config = readConfig(args.config, args);
+
+	logger.log(`Deleting queue ${args.name}.`);
+	await deleteQueue(config, args.name);
+	logger.log(`Deleted queue ${args.name}.`);
+}

package/src/queues/cli/commands/index.ts

@@ -0,0 +1,33 @@
+import { type BuilderCallback } from "yargs";
+import { type CommonYargsOptions } from "../../../yargs-types";
+import { consumers } from "./consumer";
+
+import { options as createOptions, handler as createHandler } from "./create";
+import { options as deleteOptions, handler as deleteHandler } from "./delete";
+import { options as listOptions, handler as listHandler } from "./list";
+
+export const queues: BuilderCallback<CommonYargsOptions, unknown> = (yargs) => {
+	yargs.command("list", "List Queues", listOptions, listHandler);
+
+	yargs.command(
+		"create <name>",
+		"Create a Queue",
+		createOptions,
+		createHandler
+	);
+
+	yargs.command(
+		"delete <name>",
+		"Delete a Queue",
+		deleteOptions,
+		deleteHandler
+	);
+
+	yargs.command(
+		"consumer",
+		"Configure Queue Consumers",
+		async (consumersYargs) => {
+			await consumers(consumersYargs);
+		}
+	);
+};

package/src/queues/cli/commands/list.ts

@@ -0,0 +1,25 @@
+import { type Argv } from "yargs";
+import { readConfig } from "../../../config";
+import { logger } from "../../../logger";
+import { listQueues } from "../../client";
+
+interface Args {
+	config?: string;
+	page?: number;
+}
+
+export function options(yargs: Argv): Argv<Args> {
+	return yargs.options({
+		page: {
+			type: "number",
+			describe: "Page number for pagination",
+		},
+	});
+}
+
+export async function handler(args: Args) {
+	const config = readConfig(args.config, args);
+
+	const queues = await listQueues(config, args.page);
+	logger.log(JSON.stringify(queues));
+}

package/src/queues/client.ts

@@ -0,0 +1,135 @@
+import { fetchResult } from "../cfetch";
+import { type Config } from "../config";
+import { requireAuth } from "../user";
+
+export async function createQueue(
+	config: Config,
+	body: CreateQueueBody
+): Promise<QueueResponse> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(`/accounts/${accountId}/workers/queues`, {
+		method: "POST",
+		body: JSON.stringify(body),
+	});
+}
+
+export interface CreateQueueBody {
+	queue_name: string;
+}
+
+export interface QueueResponse {
+	queue_name: string;
+	created_on: string;
+	modified_on: string;
+}
+
+export async function deleteQueue(
+	config: Config,
+	queueName: string
+): Promise<void> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}`,
+		{
+			method: "DELETE",
+		}
+	);
+}
+
+// TODO(soon) show detailed queue response
+export async function listQueues(
+	config: Config,
+	page?: number
+): Promise<QueueResponse[]> {
+	page = page ?? 1;
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues`,
+		{},
+		new URLSearchParams({ page: page.toString() })
+	);
+}
+
+export async function getQueue(
+	config: Config,
+	queueName: string
+): Promise<QueueResponse> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}`,
+		{}
+	);
+}
+
+export async function postConsumer(
+	config: Config,
+	queueName: string,
+	body: PostConsumerBody
+): Promise<ConsumerResponse> {
+	const accountId = await requireAuth(config);
+	return fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}/consumers`,
+		{
+			method: "POST",
+			body: JSON.stringify(body),
+		}
+	);
+}
+
+export interface PutConsumerBody {
+	settings: ConsumerSettings;
+	dead_letter_queue?: string;
+}
+
+export interface PostConsumerBody extends PutConsumerBody {
+	script_name: string;
+	environment_name: string;
+}
+
+export interface ConsumerSettings {
+	batch_size?: number;
+	max_retries?: number;
+	max_wait_time_ms?: number;
+}
+
+export interface ConsumerResponse extends PostConsumerBody {
+	queue_name: string;
+	script_name: string;
+	environment_name: string;
+	settings: ConsumerSettings;
+	dead_letter_queue?: string;
+}
+
+export async function deleteConsumer(
+	config: Config,
+	queueName: string,
+	scriptName: string,
+	envName?: string
+): Promise<void> {
+	const accountId = await requireAuth(config);
+	let resource = `/accounts/${accountId}/workers/queues/${queueName}/consumers/${scriptName}`;
+	if (envName !== undefined) {
+		resource += `/environments/${envName}`;
+	}
+	return fetchResult(resource, {
+		method: "DELETE",
+	});
+}
+
+export async function putConsumer(
+	config: Config,
+	queueName: string,
+	scriptName: string,
+	envName: string | undefined,
+	body: PutConsumerBody
+): Promise<ConsumerResponse> {
+	const accountId = await requireAuth(config);
+	let resource = `/accounts/${accountId}/workers/queues/${queueName}/consumers/${scriptName}`;
+	if (envName !== undefined) {
+		resource += `/environments/${envName}`;
+	}
+	return fetchResult(resource, {
+		method: "PUT",
+		body: JSON.stringify(body),
+	});
+}

package/src/r2/helpers.ts

@@ -0,0 +1,131 @@
+import { Readable } from "node:stream";
+import { fetchResult } from "../cfetch";
+import { fetchR2Objects } from "../cfetch/internal";
+import type { HeadersInit } from "undici";
+
+/**
+ * Information about a bucket, returned from `listR2Buckets()`.
+ */
+export interface R2BucketInfo {
+	name: string;
+	creation_date: string;
+}
+
+/**
+ * Fetch a list of all the buckets under the given `accountId`.
+ */
+export async function listR2Buckets(
+	accountId: string
+): Promise<R2BucketInfo[]> {
+	const results = await fetchResult<{
+		buckets: R2BucketInfo[];
+	}>(`/accounts/${accountId}/r2/buckets`);
+	return results.buckets;
+}
+
+/**
+ * Create a bucket with the given `bucketName` within the account given by `accountId`.
+ *
+ * A 400 is returned if the account already owns a bucket with this name.
+ * A bucket must be explicitly deleted to be replaced.
+ */
+export async function createR2Bucket(
+	accountId: string,
+	bucketName: string
+): Promise<void> {
+	return await fetchResult<void>(`/accounts/${accountId}/r2/buckets`, {
+		method: "POST",
+		body: JSON.stringify({ name: bucketName }),
+	});
+}
+
+/**
+ * Delete a bucket with the given name
+ */
+export async function deleteR2Bucket(
+	accountId: string,
+	bucketName: string
+): Promise<void> {
+	return await fetchResult<void>(
+		`/accounts/${accountId}/r2/buckets/${bucketName}`,
+		{ method: "DELETE" }
+	);
+}
+
+export function bucketAndKeyFromObjectPath(objectPath = ""): {
+	bucket: string;
+	key: string;
+} {
+	const match = /^([^/]+)\/(.*)/.exec(objectPath);
+	if (match === null) {
+		throw new Error(
+			`The object path must be in the form of {bucket}/{key} you provided ${objectPath}`
+		);
+	}
+
+	return { bucket: match[1], key: match[2] };
+}
+
+/**
+ * Downloads an object
+ */
+export async function getR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string
+): Promise<Readable> {
+	const response = await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{ method: "GET" }
+	);
+
+	return Readable.from(response.body);
+}
+
+/**
+ * Uploads an object
+ */
+export async function putR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string,
+	object: Readable | Buffer,
+	options: Record<string, unknown>
+): Promise<void> {
+	const headerKeys = [
+		"content-length",
+		"content-type",
+		"content-disposition",
+		"content-encoding",
+		"content-language",
+		"cache-control",
+		"expires",
+	];
+	const headers: HeadersInit = {};
+	for (const key of headerKeys) {
+		const value = options[key] || "";
+		if (value && typeof value === "string") headers[key] = value;
+	}
+
+	await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{
+			body: object,
+			headers,
+			method: "PUT",
+		}
+	);
+}
+/**
+ * Delete an Object
+ */
+export async function deleteR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string
+): Promise<void> {
+	await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{ method: "DELETE" }
+	);
+}

package/src/r2/index.ts

@@ -0,0 +1,277 @@
+import * as fs from "node:fs";
+import * as stream from "node:stream";
+
+import { readConfig } from "../config";
+import { CommandLineArgsError, printWranglerBanner } from "../index";
+import { logger } from "../logger";
+import * as metrics from "../metrics";
+import { requireAuth } from "../user";
+import {
+	bucketAndKeyFromObjectPath,
+	createR2Bucket,
+	deleteR2Bucket,
+	deleteR2Object,
+	getR2Object,
+	listR2Buckets,
+	putR2Object,
+} from "./helpers";
+
+import type { ConfigPath } from "../index";
+import type { Readable } from "node:stream";
+import type { BuilderCallback } from "yargs";
+
+export const r2: BuilderCallback<unknown, unknown> = (r2Yargs) => {
+	return r2Yargs
+		.command("object", "Manage R2 objects", (r2ObjectYargs) => {
+			return r2ObjectYargs
+				.command(
+					"get <objectPath>",
+					"Fetch an object from an R2 bucket",
+					(Objectyargs) => {
+						return Objectyargs.positional("objectPath", {
+							describe: "The source object path in the form of {bucket}/{key}",
+							type: "string",
+						})
+							.option("file", {
+								describe: "The destination file to create",
+								alias: "f",
+								conflicts: "pipe",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("pipe", {
+								describe:
+									"Enables the file to be piped to a destination, rather than specified with the --file option",
+								alias: "p",
+								conflicts: "file",
+								type: "boolean",
+							});
+					},
+					async (objectGetYargs) => {
+						const config = readConfig(
+							objectGetYargs.config as ConfigPath,
+							objectGetYargs
+						);
+						const accountId = await requireAuth(config);
+						const { objectPath, pipe } = objectGetYargs;
+						const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+
+						let file = objectGetYargs.file;
+						if (!file && !pipe) {
+							file = key;
+						}
+						if (!pipe) {
+							await printWranglerBanner();
+							logger.log(`Downloading "${key}" from "${bucket}".`);
+						}
+						const input = await getR2Object(accountId, bucket, key);
+						const output = file ? fs.createWriteStream(file) : process.stdout;
+						await new Promise<void>((resolve, reject) => {
+							stream.pipeline(input, output, (err: unknown) => {
+								err ? reject(err) : resolve();
+							});
+						});
+						if (!pipe) logger.log("Download complete.");
+					}
+				)
+				.command(
+					"put <objectPath>",
+					"Create an object in an R2 bucket",
+					(Objectyargs) => {
+						return Objectyargs.positional("objectPath", {
+							describe:
+								"The destination object path in the form of {bucket}/{key}",
+							type: "string",
+						})
+							.option("file", {
+								describe: "The path of the file to upload",
+								alias: "f",
+								conflicts: "pipe",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("pipe", {
+								describe:
+									"Enables the file to be piped in, rather than specified with the --file option",
+								alias: "p",
+								conflicts: "file",
+								type: "boolean",
+							})
+							.option("content-type", {
+								describe:
+									"A standard MIME type describing the format of the object data",
+								alias: "ct",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("content-disposition", {
+								describe: "Specifies presentational information for the object",
+								alias: "cd",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("content-encoding", {
+								describe:
+									"Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field",
+								alias: "ce",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("content-language", {
+								describe: "The language the content is in",
+								alias: "cl",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("cache-control", {
+								describe:
+									"Specifies caching behavior along the request/reply chain",
+								alias: "cc",
+								requiresArg: true,
+								type: "string",
+							})
+							.option("expires", {
+								describe:
+									"The date and time at which the object is no longer cacheable",
+								alias: "e",
+								requiresArg: true,
+								type: "string",
+							});
+					},
+					async (objectPutYargs) => {
+						await printWranglerBanner();
+
+						const config = readConfig(
+							objectPutYargs.config as ConfigPath,
+							objectPutYargs
+						);
+						const accountId = await requireAuth(config);
+						const { objectPath, file, pipe, ...options } = objectPutYargs;
+						const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+						if (!file && !pipe) {
+							throw new CommandLineArgsError(
+								"Either the --file or --pipe options are required."
+							);
+						}
+						let object: Readable | Buffer;
+						let objectSize: number;
+						if (file) {
+							object = fs.createReadStream(file);
+							const stats = fs.statSync(file);
+							objectSize = stats.size;
+						} else {
+							object = await new Promise<Buffer>((resolve, reject) => {
+								const stdin = process.stdin;
+								const chunks = Array<Buffer>();
+								stdin.on("data", (chunk) => chunks.push(chunk));
+								stdin.on("end", () => resolve(Buffer.concat(chunks)));
+								stdin.on("error", (err) =>
+									reject(
+										new CommandLineArgsError(
+											`Could not pipe. Reason: "${err.message}"`
+										)
+									)
+								);
+							});
+							objectSize = object.byteLength;
+						}
+
+						logger.log(`Creating object "${key}" in bucket "${bucket}".`);
+						await putR2Object(accountId, bucket, key, object, {
+							...options,
+							"content-length": `${objectSize}`,
+						});
+						logger.log("Upload complete.");
+					}
+				)
+				.command(
+					"delete <objectPath>",
+					"Delete an object in an R2 bucket",
+					(objectDeleteYargs) => {
+						return objectDeleteYargs.positional("objectPath", {
+							describe:
+								"The destination object path in the form of {bucket}/{key}",
+							type: "string",
+						});
+					},
+					async (args) => {
+						const { objectPath } = args;
+						await printWranglerBanner();
+
+						const config = readConfig(args.config as ConfigPath, args);
+						const accountId = await requireAuth(config);
+						const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+						logger.log(`Deleting object "${key}" from bucket "${bucket}".`);
+
+						await deleteR2Object(accountId, bucket, key);
+						logger.log("Delete complete.");
+					}
+				);
+		})
+
+		.command("bucket", "Manage R2 buckets", (r2BucketYargs) => {
+			r2BucketYargs.command(
+				"create <name>",
+				"Create a new R2 bucket",
+				(yargs) => {
+					return yargs.positional("name", {
+						describe: "The name of the new bucket",
+						type: "string",
+						demandOption: true,
+					});
+				},
+				async (args) => {
+					await printWranglerBanner();
+
+					const config = readConfig(args.config as ConfigPath, args);
+
+					const accountId = await requireAuth(config);
+
+					logger.log(`Creating bucket ${args.name}.`);
+					await createR2Bucket(accountId, args.name);
+					logger.log(`Created bucket ${args.name}.`);
+					await metrics.sendMetricsEvent("create r2 bucket", {
+						sendMetrics: config.send_metrics,
+					});
+				}
+			);
+
+			r2BucketYargs.command("list", "List R2 buckets", {}, async (args) => {
+				const config = readConfig(args.config as ConfigPath, args);
+
+				const accountId = await requireAuth(config);
+
+				logger.log(JSON.stringify(await listR2Buckets(accountId), null, 2));
+				await metrics.sendMetricsEvent("list r2 buckets", {
+					sendMetrics: config.send_metrics,
+				});
+			});
+
+			r2BucketYargs.command(
+				"delete <name>",
+				"Delete an R2 bucket",
+				(yargs) => {
+					return yargs.positional("name", {
+						describe: "The name of the bucket to delete",
+						type: "string",
+						demandOption: true,
+					});
+				},
+				async (args) => {
+					await printWranglerBanner();
+
+					const config = readConfig(args.config as ConfigPath, args);
+
+					const accountId = await requireAuth(config);
+
+					logger.log(`Deleting bucket ${args.name}.`);
+					await deleteR2Bucket(accountId, args.name);
+					logger.log(`Deleted bucket ${args.name}.`);
+					await metrics.sendMetricsEvent("delete r2 bucket", {
+						sendMetrics: config.send_metrics,
+					});
+				}
+			);
+			return r2BucketYargs;
+		});
+};