devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/_chunks/schema-normalization-DWVleVxo.js

@@ -0,0 +1,477 @@
+import { z } from "zod";
+//#region src/config/schema-bindings.ts
+/**
+* Durable Object binding schema.
+* Validates DO binding configuration in either string or object form.
+*/
+const durableObjectBindingSchema = z.custom((val) => {
+	if (typeof val === "string") return true;
+	if (val && typeof val === "object" && "className" in val) return typeof val.className === "string";
+	return false;
+}, { message: "Expected string or { className: string, scriptName?: string }" });
+/**
+* Queue consumer configuration.
+* Defines how messages are consumed from a Cloudflare Queue.
+*/
+const queueConsumerSchema = z.object({
+	queue: z.string(),
+	maxBatchSize: z.number().optional(),
+	maxBatchTimeout: z.number().optional(),
+	maxRetries: z.number().optional(),
+	deadLetterQueue: z.string().optional(),
+	maxConcurrency: z.number().optional(),
+	retryDelay: z.number().optional()
+});
+/**
+* Queues configuration for producers and consumers.
+*/
+const queuesConfigSchema = z.object({
+	producers: z.record(z.string(), z.string()).optional(),
+	consumers: z.array(queueConsumerSchema).optional()
+});
+/**
+* Rate Limiting binding configuration.
+* Devflare uses camelCase authoring and compiles to Wrangler's `ratelimits`
+* array (`namespace_id`, `simple.limit`, `simple.period`).
+*/
+const rateLimitBindingSchema = z.object({
+	namespaceId: z.string().regex(/^[1-9]\d*$/, "namespaceId must be a positive integer string"),
+	simple: z.object({
+		limit: z.number().int().positive(),
+		period: z.union([z.literal(10), z.literal(60)])
+	}).strict()
+}).strict();
+/**
+* Version Metadata binding configuration.
+*/
+const versionMetadataBindingSchema = z.object({ binding: z.string().min(1) }).strict();
+/**
+* Worker Loader binding configuration for Dynamic Workers.
+*/
+const workerLoaderBindingSchema = z.object({}).strict();
+/**
+* Secrets Store binding configuration.
+* Devflare accepts object form for explicit per-binding store IDs and string
+* shorthand when the worker sets a top-level `secretsStoreId`.
+*/
+const secretsStoreBindingSchema = z.union([z.string().min(1), z.object({
+	storeId: z.string().min(1),
+	secretName: z.string().min(1)
+}).strict()]);
+/**
+* Service binding schema.
+* Binds to another Worker for RPC-style communication.
+* Accepts plain objects or WorkerBinding from ref().worker.
+*/
+const serviceBindingKeys = new Set([
+	"service",
+	"environment",
+	"entrypoint",
+	"__ref"
+]);
+function isServiceBindingValue(val) {
+	if (typeof val !== "object" && typeof val !== "function" || val === null) return false;
+	const obj = val;
+	if (typeof obj.service !== "string" || obj.service.trim().length === 0) return false;
+	if (obj.environment !== void 0 && (typeof obj.environment !== "string" || obj.environment.trim().length === 0)) return false;
+	if (obj.entrypoint !== void 0 && (typeof obj.entrypoint !== "string" || obj.entrypoint.trim().length === 0)) return false;
+	if (typeof val === "object") {
+		for (const key of Object.keys(obj)) if (!serviceBindingKeys.has(key)) return false;
+	}
+	return true;
+}
+const serviceBindingSchema = z.custom(isServiceBindingValue, { message: "Expected service binding object with { service: string, environment?: string, entrypoint?: string } or ref().worker" });
+/**
+* AI binding configuration.
+* Provides access to Cloudflare Workers AI for inference.
+*/
+const aiBindingSchema = z.object({
+	binding: z.string(),
+	remote: z.boolean().optional(),
+	staging: z.boolean().optional()
+}).strict();
+/**
+* AI Search namespace binding configuration.
+* Provides access to all AI Search instances in a namespace.
+*/
+const aiSearchNamespaceBindingSchema = z.object({
+	namespace: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict();
+/**
+* AI Search instance binding configuration.
+* Provides direct access to one AI Search instance in the default namespace.
+*/
+const aiSearchInstanceBindingSchema = z.object({
+	instanceName: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict();
+/**
+* Vectorize index binding configuration.
+* Provides access to a Cloudflare Vectorize index for similarity search.
+*/
+const vectorizeBindingSchema = z.object({
+	indexName: z.string(),
+	remote: z.boolean().optional()
+});
+/**
+* Hyperdrive binding configuration.
+* Provides accelerated PostgreSQL connections via connection pooling.
+*/
+const hyperdriveBindingByIdSchema = z.object({
+	id: z.string(),
+	localConnectionString: z.string().optional()
+}).strict();
+const hyperdriveBindingByNameSchema = z.object({
+	name: z.string(),
+	localConnectionString: z.string().optional(),
+	previewFallback: z.literal("base").optional(),
+	previewId: z.string().optional(),
+	previewLocalConnectionString: z.string().optional()
+}).strict();
+const hyperdriveBindingSchema = z.union([
+	z.string(),
+	hyperdriveBindingByIdSchema,
+	hyperdriveBindingByNameSchema
+]);
+const SINGLE_BROWSER_BINDING_ERROR_MESSAGE = "Devflare currently supports exactly one browser binding because Wrangler only supports a single browser binding.";
+function formatBrowserBindingLimitMessage(bindingNames) {
+	if (bindingNames.length <= 1) return SINGLE_BROWSER_BINDING_ERROR_MESSAGE;
+	return `${SINGLE_BROWSER_BINDING_ERROR_MESSAGE} Configured bindings: ${bindingNames.join(", ")}`;
+}
+function getBrowserBindingNames(bindings) {
+	return bindings ? Object.keys(bindings) : [];
+}
+/**
+* Browser Rendering binding configuration.
+* Provides headless browser access for rendering/screenshots.
+*/
+const browserBindingValueSchema = z.union([z.string(), z.object({ remote: z.boolean().optional() }).strict()]);
+const browserBindingSchema = z.record(z.string(), browserBindingValueSchema).superRefine((bindings, ctx) => {
+	const bindingNames = getBrowserBindingNames(bindings);
+	if (bindingNames.length > 1) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: formatBrowserBindingLimitMessage(bindingNames)
+	});
+});
+/**
+* Analytics Engine binding configuration.
+* Provides access to Cloudflare Analytics Engine for event logging.
+*/
+const analyticsBindingSchema = z.object({ dataset: z.string() });
+/**
+* Email sending binding configuration.
+* Enables sending emails via Cloudflare Email Routing.
+*/
+const sendEmailBindingSchema = z.object({
+	destinationAddress: z.string().optional(),
+	allowedDestinationAddresses: z.array(z.string()).optional(),
+	allowedSenderAddresses: z.array(z.string()).optional()
+}).refine((binding) => {
+	return !(binding.destinationAddress && binding.allowedDestinationAddresses);
+}, {
+	message: "sendEmail bindings must use either destinationAddress or allowedDestinationAddresses, not both",
+	path: ["allowedDestinationAddresses"]
+});
+const d1BindingByIdSchema = z.object({ id: z.string() }).strict();
+const d1BindingByNameSchema = z.object({ name: z.string() }).strict();
+const d1BindingSchema = z.union([
+	z.string(),
+	d1BindingByIdSchema,
+	d1BindingByNameSchema
+]);
+const kvBindingByIdSchema = z.object({ id: z.string() }).strict();
+const kvBindingByNameSchema = z.object({ name: z.string() }).strict();
+const kvBindingSchema = z.union([
+	z.string(),
+	kvBindingByIdSchema,
+	kvBindingByNameSchema
+]);
+const mtlsCertificateBindingByIdSchema = z.object({
+	certificateId: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict();
+const mtlsCertificateBindingByWranglerIdSchema = z.object({
+	certificate_id: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict();
+/**
+* C17 — mTLS Certificate binding.
+* The id is the UUID returned by `wrangler mtls-certificate upload`.
+*/
+const mtlsCertificateBindingSchema = z.union([
+	z.string().min(1),
+	mtlsCertificateBindingByIdSchema,
+	mtlsCertificateBindingByWranglerIdSchema
+]);
+/**
+* C17 — Workers for Platforms (Dispatch Namespace) binding.
+*/
+const dispatchNamespaceBindingSchema = z.union([z.string().min(1), z.object({
+	namespace: z.string().min(1),
+	outbound: z.object({
+		service: z.string().min(1),
+		environment: z.string().optional(),
+		parameters: z.array(z.string()).optional()
+	}).strict().optional(),
+	remote: z.boolean().optional()
+}).strict()]);
+/**
+* C17 — Workflows-as-binding (a workflow class exposed for another worker
+* to invoke). Distinct from a worker declaring its own workflows.
+*/
+const workflowBindingSchema = z.object({
+	name: z.string().min(1),
+	className: z.string().min(1),
+	scriptName: z.string().min(1).optional(),
+	remote: z.boolean().optional(),
+	limits: z.object({ steps: z.number().int().positive() }).strict().optional()
+}).strict();
+/**
+* C17 — Cloudflare Pipelines binding.
+*/
+const pipelineBindingSchema = z.union([z.string().min(1), z.object({
+	pipeline: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict()]);
+/**
+* C17 — Cloudflare Images binding (transformation/upload service).
+*/
+const imagesBindingSchema = z.object({ remote: z.boolean().optional() }).strict().or(z.literal(true));
+/**
+* C17 — Cloudflare Media Transformations binding.
+*/
+const mediaBindingSchema = z.object({ remote: z.boolean().optional() }).strict().or(z.literal(true));
+/**
+* C17 — Cloudflare Artifacts binding.
+*/
+const artifactsBindingSchema = z.union([z.string().min(1), z.object({
+	namespace: z.string().min(1),
+	remote: z.boolean().optional()
+}).strict()]);
+/**
+* All worker bindings configuration.
+* Defines connections to Cloudflare services and resources.
+*/
+const bindingsSchema = z.object({
+	kv: z.record(z.string(), kvBindingSchema).optional(),
+	d1: z.record(z.string(), d1BindingSchema).optional(),
+	r2: z.record(z.string(), z.string()).optional(),
+	durableObjects: z.record(z.string(), durableObjectBindingSchema).optional(),
+	queues: queuesConfigSchema.optional(),
+	rateLimits: z.record(z.string(), rateLimitBindingSchema).optional(),
+	versionMetadata: versionMetadataBindingSchema.optional(),
+	workerLoaders: z.record(z.string(), workerLoaderBindingSchema).optional(),
+	secretsStore: z.record(z.string(), secretsStoreBindingSchema).optional(),
+	services: z.record(z.string(), serviceBindingSchema).optional(),
+	ai: aiBindingSchema.optional(),
+	aiSearchNamespaces: z.record(z.string(), aiSearchNamespaceBindingSchema).optional(),
+	aiSearch: z.record(z.string(), aiSearchInstanceBindingSchema).optional(),
+	vectorize: z.record(z.string(), vectorizeBindingSchema).optional(),
+	hyperdrive: z.record(z.string(), hyperdriveBindingSchema).optional(),
+	browser: browserBindingSchema.optional(),
+	analyticsEngine: z.record(z.string(), analyticsBindingSchema).optional(),
+	sendEmail: z.record(z.string(), sendEmailBindingSchema).optional(),
+	mtlsCertificates: z.record(z.string(), mtlsCertificateBindingSchema).optional(),
+	dispatchNamespaces: z.record(z.string(), dispatchNamespaceBindingSchema).optional(),
+	workflows: z.record(z.string(), workflowBindingSchema).optional(),
+	pipelines: z.record(z.string(), pipelineBindingSchema).optional(),
+	images: z.record(z.string(), imagesBindingSchema).optional().superRefine((bindings, ctx) => {
+		if (!bindings || Object.keys(bindings).length <= 1) return;
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Wrangler currently supports one Images binding per Worker"
+		});
+	}),
+	media: z.record(z.string(), mediaBindingSchema).optional().superRefine((bindings, ctx) => {
+		if (!bindings || Object.keys(bindings).length <= 1) return;
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Wrangler currently supports one Media Transformations binding per Worker"
+		});
+	}),
+	artifacts: z.record(z.string(), artifactsBindingSchema).optional()
+}).optional();
+//#endregion
+//#region src/config/schema-normalization.ts
+/**
+* Return the single browser binding name, or `undefined` when no browser
+* binding is configured.
+*
+* invariant: `bindings` is expected to have been validated by
+* `browserBindingSchema` (see `schema-bindings.ts`), which rejects
+* configurations with more than one browser binding via
+* `superRefine` + `formatBrowserBindingLimitMessage`. Callers that bypass
+* Zod (e.g. by casting raw input as `DevflareConfig`) should re-validate
+* via `browserBindingSchema.parse()` before relying on this selector.
+*/
+function getSingleBrowserBindingName(bindings) {
+	const bindingNames = getBrowserBindingNames(bindings);
+	if (bindingNames.length === 0) return;
+	return bindingNames[0];
+}
+/**
+* Normalize a DO binding to its object form.
+*/
+function normalizeDOBinding(config) {
+	if (typeof config === "string") return {
+		className: config,
+		kind: "local"
+	};
+	const scriptName = config.scriptName;
+	const __ref = config.__ref;
+	const kind = scriptName || __ref ? "cross-worker" : "local";
+	return {
+		className: config.className,
+		scriptName,
+		__ref,
+		kind
+	};
+}
+/**
+* Normalize a D1 binding to a consistent object form.
+* String bindings are treated as stable database names.
+*/
+function normalizeD1Binding(config) {
+	if (typeof config === "string") return { name: config };
+	if ("id" in config) return { databaseId: config.id };
+	return { name: config.name };
+}
+/**
+* Normalize a KV binding to a consistent object form.
+* String bindings are treated as stable namespace names.
+*/
+function normalizeKVBinding(config) {
+	if (typeof config === "string") return { name: config };
+	if ("id" in config) return { namespaceId: config.id };
+	return { name: config.name };
+}
+/**
+* Normalize a Hyperdrive binding to a consistent object form.
+* String bindings are treated as stable Hyperdrive configuration names.
+*/
+function normalizeHyperdriveBinding(config) {
+	if (typeof config === "string") return { name: config };
+	const localConnectionString = "localConnectionString" in config ? config.localConnectionString : "previewLocalConnectionString" in config ? config.previewLocalConnectionString : void 0;
+	if ("id" in config) return {
+		configurationId: config.id,
+		...localConnectionString && { localConnectionString }
+	};
+	return {
+		name: config.name,
+		...localConnectionString && { localConnectionString }
+	};
+}
+/**
+* Normalize an mTLS certificate binding to Devflare's camelCase shape.
+*/
+function normalizeMtlsCertificateBinding(config) {
+	if (typeof config === "string") return { certificateId: config };
+	if ("certificateId" in config) return {
+		certificateId: config.certificateId,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+	return {
+		certificateId: config.certificate_id,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize a Dispatch Namespace binding to its object form.
+*/
+function normalizeDispatchNamespaceBinding(config) {
+	if (typeof config === "string") return { namespace: config };
+	return {
+		namespace: config.namespace,
+		...config.outbound && { outbound: {
+			service: config.outbound.service,
+			...config.outbound.environment && { environment: config.outbound.environment },
+			...config.outbound.parameters && { parameters: config.outbound.parameters }
+		} },
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize a Workflow binding to its object form.
+*/
+function normalizeWorkflowBinding(config) {
+	return {
+		name: config.name,
+		className: config.className,
+		...config.scriptName && { scriptName: config.scriptName },
+		...config.remote !== void 0 && { remote: config.remote },
+		...config.limits && { limits: { steps: config.limits.steps } }
+	};
+}
+/**
+* Normalize a Pipeline binding to its object form.
+*/
+function normalizePipelineBinding(config) {
+	if (typeof config === "string") return { pipeline: config };
+	return {
+		pipeline: config.pipeline,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize an Images binding to Wrangler's singleton binding object.
+*/
+function normalizeImagesBinding(binding, config) {
+	if (config === true) return { binding };
+	return {
+		binding,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize a Media Transformations binding to Wrangler's singleton binding object.
+*/
+function normalizeMediaBinding(binding, config) {
+	if (config === true) return { binding };
+	return {
+		binding,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize an Artifacts binding to its object form.
+*/
+function normalizeArtifactsBinding(config) {
+	if (typeof config === "string") return { namespace: config };
+	return {
+		namespace: config.namespace,
+		...config.remote !== void 0 && { remote: config.remote }
+	};
+}
+/**
+* Normalize a Secrets Store binding to its explicit store/name form.
+*/
+function normalizeSecretsStoreBinding(config, defaultStoreId, bindingName = "unknown") {
+	if (typeof config === "string") {
+		if (!defaultStoreId) throw new Error(`Secrets Store binding "${bindingName}" uses shorthand and requires top-level secretsStoreId.`);
+		return {
+			storeId: defaultStoreId,
+			secretName: config
+		};
+	}
+	return {
+		storeId: config.storeId,
+		secretName: config.secretName
+	};
+}
+/**
+* Get the identifier Devflare should use for local/runtime KV wiring.
+*/
+function getLocalKVNamespaceIdentifier(config) {
+	const normalized = normalizeKVBinding(config);
+	return normalized.namespaceId ?? normalized.name ?? "";
+}
+/**
+* Get the identifier Devflare should use for local/runtime D1 wiring.
+*/
+function getLocalD1DatabaseIdentifier(config) {
+	const normalized = normalizeD1Binding(config);
+	return normalized.databaseId ?? normalized.name ?? "";
+}
+//#endregion
+export { browserBindingSchema as _, normalizeD1Binding as a, normalizeHyperdriveBinding as c, normalizeMediaBinding as d, normalizeMtlsCertificateBinding as f, bindingsSchema as g, normalizeWorkflowBinding as h, normalizeArtifactsBinding as i, normalizeImagesBinding as l, normalizeSecretsStoreBinding as m, getLocalKVNamespaceIdentifier as n, normalizeDOBinding as o, normalizePipelineBinding as p, getSingleBrowserBindingName as r, normalizeDispatchNamespaceBinding as s, getLocalD1DatabaseIdentifier as t, normalizeKVBinding as u };

package/dist/_chunks/secrets-70eN0Q6C.js

@@ -0,0 +1,95 @@
+import { i as listLocalSecrets, o as writeLocalSecret, r as deleteLocalSecret } from "./local-secrets-DMmEOygL.js";
+//#region src/cli/commands/secrets.ts
+function getStringOption(options, key) {
+	const value = options[key];
+	return typeof value === "string" ? value : void 0;
+}
+function getCwd(options) {
+	return options.cwd ?? process.cwd();
+}
+function requireLocalFlag(parsed, logger) {
+	if (parsed.options.local === true) return true;
+	logger.error("Local Secrets Store commands require --local.");
+	return false;
+}
+function requireStoreAndName(parsed, logger) {
+	const storeId = getStringOption(parsed.options, "store");
+	const name = getStringOption(parsed.options, "name");
+	if (!storeId || !name) {
+		logger.error("Pass --store <id> and --name <name>.");
+		return;
+	}
+	return {
+		storeId,
+		name
+	};
+}
+function formatSecretRef(storeId, name) {
+	return `${storeId}/${name}`;
+}
+function usage() {
+	return [
+		"devflare secrets --local --store <id> --name <name> --value <value>",
+		"devflare secrets --local --store <id> --list",
+		"devflare secrets --local --store <id> --name <name> --delete"
+	].join("\n");
+}
+function runSecretsCommand(parsed, logger, options) {
+	if (!requireLocalFlag(parsed, logger)) return {
+		exitCode: 1,
+		output: usage()
+	};
+	const cwd = getCwd(options);
+	const storeId = getStringOption(parsed.options, "store");
+	if (parsed.options.list === true) {
+		const output = listLocalSecrets({
+			cwd,
+			storeId
+		}).map((row) => formatSecretRef(row.storeId, row.name)).join("\n");
+		if (output) logger.info(output);
+		return {
+			exitCode: 0,
+			output
+		};
+	}
+	const required = requireStoreAndName(parsed, logger);
+	if (!required) return {
+		exitCode: 1,
+		output: usage()
+	};
+	if (parsed.options.delete === true) {
+		deleteLocalSecret({
+			cwd,
+			storeId: required.storeId,
+			name: required.name
+		});
+		const output = formatSecretRef(required.storeId, required.name);
+		logger.success(`Deleted local secret ${output}`);
+		return {
+			exitCode: 0,
+			output
+		};
+	}
+	const value = getStringOption(parsed.options, "value");
+	if (value === void 0) {
+		logger.error("Pass --value <value>, --list, or --delete.");
+		return {
+			exitCode: 1,
+			output: usage()
+		};
+	}
+	writeLocalSecret({
+		cwd,
+		storeId: required.storeId,
+		name: required.name,
+		value
+	});
+	const output = formatSecretRef(required.storeId, required.name);
+	logger.success(`Stored local secret ${output}`);
+	return {
+		exitCode: 0,
+		output
+	};
+}
+//#endregion
+export { runSecretsCommand };