@geekmidas/envkit 9.0.2 → 10.0.0-alpha.1

package/src/SstEnvValidator.ts

@@ -1,369 +0,0 @@
-import { EnvironmentBuilder, type InputValue } from './EnvironmentBuilder';
-import { type SstResource, sstResolvers } from './SstEnvironmentBuilder';
-
-/**
- * Variables AWS Lambda injects into the runtime. Always valid on AWS, but never
- * assumed — opt in via `platform: 'aws'` or by spreading {@link AWS_RUNTIME_ENV_VARS}
- * into `whitelist`.
- */
-export const AWS_RUNTIME_ENV_VARS = [
-	'AWS_REGION',
-	'AWS_DEFAULT_REGION',
-	'AWS_ENDPOINT_URL',
-	'AWS_ENDPOINT',
-	'AWS_ACCESS_KEY_ID',
-	'AWS_SECRET_ACCESS_KEY',
-	'AWS_SESSION_TOKEN',
-	'AWS_LAMBDA_FUNCTION_NAME',
-	'AWS_LAMBDA_FUNCTION_VERSION',
-] as const;
-
-/**
- * Variables GCP injects into Cloud Functions / Cloud Run.
- */
-export const GCP_RUNTIME_ENV_VARS = [
-	'GOOGLE_CLOUD_PROJECT',
-	'GCP_PROJECT',
-	'FUNCTION_TARGET',
-	'FUNCTION_SIGNATURE_TYPE',
-	'K_SERVICE',
-	'K_REVISION',
-	'K_CONFIGURATION',
-	'PORT',
-] as const;
-
-/**
- * Variables Cloudflare exposes to Workers. Workers inject almost nothing into
- * the global env, so this is intentionally minimal.
- */
-export const CLOUDFLARE_RUNTIME_ENV_VARS = [
-	'CF_PAGES',
-	'CF_PAGES_URL',
-] as const;
-
-/**
- * Registry of platform → always-valid runtime variables. Export, don't assume:
- * a caller states the platform it deploys to and the matching set is trusted.
- */
-export const PLATFORM_ENV_VARS = {
-	aws: AWS_RUNTIME_ENV_VARS,
-	gcp: GCP_RUNTIME_ENV_VARS,
-	cloudflare: CLOUDFLARE_RUNTIME_ENV_VARS,
-} as const;
-
-export type Platform = keyof typeof PLATFORM_ENV_VARS;
-
-/**
- * The always-valid runtime variables for a platform. The "whitelist construct":
- * resolve a platform to its set, to spread into `whitelist` or compare against.
- */
-export function platformEnvVars(platform: Platform): readonly string[] {
-	return PLATFORM_ENV_VARS[platform];
-}
-
-/** How many link-provided vars to list in an error before truncating. */
-const MAX_LISTED_VARS = 8;
-
-/** Minimum similarity for a variable to be offered as a "did you mean". */
-const SUGGESTION_THRESHOLD = 0.3;
-
-/**
- * Input shape for the validator: the same record `SstEnvironmentBuilder`
- * accepts — keyed by resource name, valued by an SST resource (or a plain
- * string for pass-through env vars).
- */
-export type LinkRecord = Record<string, SstResource | InputValue | string>;
-
-export interface ValidationResult {
-	valid: boolean;
-	/** Requested variables that are not available (excluding optional `?` vars). */
-	invalidVars: string[];
-	/** Every variable the links + whitelist make available. */
-	availableVars: string[];
-	/** Nearest available matches for each invalid variable (best first). */
-	suggestions: Record<string, string[]>;
-}
-
-export interface EnvValidatorOptions {
-	/**
-	 * Platform whose runtime-injected variables are always valid. Omit to assume
-	 * none — the validator never bakes in a platform's variables.
-	 */
-	platform?: Platform;
-	/**
-	 * Extra always-valid variables in addition to the platform set — typically
-	 * the keys of a function's explicit `environment`.
-	 */
-	whitelist?: readonly string[];
-	/**
-	 * Label for the deployable unit (e.g. a function name), used in error
-	 * messages so a failure points at exactly one unit.
-	 */
-	context?: string;
-}
-
-/**
- * Levenshtein edit distance between two strings.
- */
-function levenshtein(a: string, b: string): number {
-	const m = a.length;
-	const n = b.length;
-	if (m === 0) return n;
-	if (n === 0) return m;
-
-	let prev = Array.from({ length: n + 1 }, (_, i) => i);
-
-	for (let i = 1; i <= m; i++) {
-		const curr: number[] = [i];
-		for (let j = 1; j <= n; j++) {
-			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-			const del = (prev[j] ?? 0) + 1;
-			const ins = (curr[j - 1] ?? 0) + 1;
-			const sub = (prev[j - 1] ?? 0) + cost;
-			curr[j] = Math.min(del, ins, sub);
-		}
-		prev = curr;
-	}
-
-	return prev[n] ?? 0;
-}
-
-/**
- * Similarity in `[0, 1]` combining edit distance with `_`-token overlap, so both
- * near-typos (a missing underscore) and renames (`DATABASE_URL` ~ `DB_URL`,
- * which share the `URL` token) are caught.
- */
-function similarity(a: string, b: string): number {
-	const editSim = 1 - levenshtein(a, b) / Math.max(a.length, b.length, 1);
-
-	const ta = new Set(a.split('_').filter(Boolean));
-	const tb = new Set(b.split('_').filter(Boolean));
-	const shared = [...ta].filter((t) => tb.has(t)).length;
-	const union = new Set([...ta, ...tb]).size || 1;
-	const tokenSim = shared / union;
-
-	// Nudge token-overlap matches ahead of coincidental edit-distance ones, so a
-	// rename like DATABASE_URL prefers DB_URL (shares `URL`) over DB_PASSWORD.
-	return Math.max(editSim, tokenSim * 1.15);
-}
-
-/**
- * Returns the nearest available variables to `missing`, best first, limited to
- * those above {@link SUGGESTION_THRESHOLD}.
- */
-function suggestionsFor(
-	missing: string,
-	available: readonly string[],
-	max = 1,
-): string[] {
-	return available
-		.map((candidate) => ({ candidate, score: similarity(missing, candidate) }))
-		.filter((s) => s.score >= SUGGESTION_THRESHOLD)
-		.sort((a, b) => b.score - a.score)
-		.slice(0, max)
-		.map((s) => s.candidate);
-}
-
-/**
- * Thrown when a deployable unit requires environment variables its links do not
- * provide. Carries the structured `missing`/`available`/`suggestions` so callers
- * can inspect the failure programmatically, not just read the message.
- */
-export class EnvValidationError extends Error {
-	readonly isEnvValidationError = true;
-	readonly missing: string[];
-	readonly available: string[];
-	readonly suggestions: Record<string, string[]>;
-	readonly context?: string;
-
-	constructor(args: {
-		missing: string[];
-		available: string[];
-		linkVars: string[];
-		suggestions: Record<string, string[]>;
-		context?: string;
-	}) {
-		super(EnvValidationError.format(args));
-		this.name = 'EnvValidationError';
-		this.missing = args.missing;
-		this.available = args.available;
-		this.suggestions = args.suggestions;
-		this.context = args.context;
-		// V8-only; keeps the constructor out of the stack trace.
-		(
-			Error as unknown as {
-				captureStackTrace?(target: object, ctor?: unknown): void;
-			}
-		).captureStackTrace?.(this, EnvValidationError);
-	}
-
-	private static format(args: {
-		missing: string[];
-		linkVars: string[];
-		suggestions: Record<string, string[]>;
-		context?: string;
-	}): string {
-		const { missing, linkVars, suggestions, context } = args;
-		const who = context ? `'${context}'` : 'a deployable unit';
-
-		const width = Math.max(...missing.map((v) => v.length));
-		const lines = missing.map((v) => {
-			const hints = suggestions[v] ?? [];
-			const hint = hints.length ? `(did you mean ${hints.join(' or ')}?)` : '';
-			return `  - ${v.padEnd(width)}  ${hint}`.trimEnd();
-		});
-
-		let provided: string;
-		if (linkVars.length === 0) {
-			provided = '(no links provide environment variables)';
-		} else {
-			const shown = linkVars.slice(0, MAX_LISTED_VARS).join(', ');
-			const extra =
-				linkVars.length > MAX_LISTED_VARS
-					? ` ...(+${linkVars.length - MAX_LISTED_VARS})`
-					: '';
-			provided = `Provided by links: ${shown}${extra}`;
-		}
-
-		return `${who} is missing required env vars:\n${lines.join('\n')}\n\n${provided}`;
-	}
-}
-
-/**
- * Derives the set of environment-variable **keys** a group of linked resources
- * will produce at runtime — without resolving any value.
- *
- * This reuses the runtime resolvers (`sstResolvers`) via {@link EnvironmentBuilder},
- * so the keys computed here are exactly the keys a deployed function receives:
- * the validator and the runtime resolution share a single source of truth and
- * cannot drift. Because every resolver's output keys depend only on the record
- * key and the resource `type` (never the value), each resource is reduced to
- * `{ type }` before building, so no SST `Output` is ever read.
- *
- * @example
- * resolveEnvKeys({ db: { type: ResourceType.Postgres } });
- * // ['DB_NAME', 'DB_HOST', 'DB_PASSWORD', 'DB_PORT', 'DB_USERNAME', 'DB_URL']
- */
-export function resolveEnvKeys(record: LinkRecord): string[] {
-	const typeOnly: Record<string, InputValue> = {};
-	for (const [key, value] of Object.entries(record)) {
-		typeOnly[key] = typeof value === 'string' ? '' : { type: value.type };
-	}
-	return Object.keys(new EnvironmentBuilder(typeOnly, sstResolvers).build());
-}
-
-/**
- * Validates that the environment variables a deployable unit requires are
- * actually provided by its linked resources — at infra time, before deploy.
- *
- * Available variables are the union of the keys derived from `links`
- * ({@link resolveEnvKeys}), the chosen platform's runtime variables (only when
- * `options.platform` is set — nothing is assumed), and any `options.whitelist`
- * (e.g. the keys of a function's explicit `environment`). A requested variable
- * suffixed with `?` is treated as optional and never causes a failure.
- *
- * @example
- * const validator = new EnvValidator(
- *   { db: { type: ResourceType.Postgres } },
- *   { platform: 'aws', whitelist: ['APP_NAME'], context: 'orders-fn' },
- * );
- * validator.assert(['DB_HOST', 'AWS_REGION', 'APP_NAME', 'SENTRY_DSN?']); // ok
- * validator.assert(['DATABASE_URL']); // throws EnvValidationError (did you mean DB_URL?)
- */
-export class EnvValidator {
-	/** Every variable available — link-derived, platform, and extra whitelist. */
-	readonly availableVars: string[];
-	/** Just the variables the links provide (used for error context). */
-	readonly linkVars: string[];
-	readonly context?: string;
-	private readonly availableSet: Set<string>;
-	/** Per-link (record key → its env-var keys), for least-privilege filtering. */
-	private readonly linkVarsByName: Map<string, string[]>;
-
-	constructor(links: LinkRecord, options: EnvValidatorOptions = {}) {
-		const { platform, whitelist = [], context } = options;
-		this.context = context;
-		this.linkVarsByName = new Map(
-			Object.entries(links).map(([name, value]) => [
-				name,
-				resolveEnvKeys({ [name]: value }),
-			]),
-		);
-		this.linkVars = [...this.linkVarsByName.values()].flat();
-		this.availableVars = [
-			...this.linkVars,
-			...(platform ? PLATFORM_ENV_VARS[platform] : []),
-			...whitelist,
-		];
-		this.availableSet = new Set(this.availableVars);
-	}
-
-	/**
-	 * Returns the names of the links that provide at least one of the requested
-	 * variables — so a construct can attach only the links a unit actually needs
-	 * (least privilege) rather than the whole pool. Trailing `?` is ignored.
-	 */
-	getProvidersForEnvVars(requestedEnvVars: readonly string[]): string[] {
-		const requested = new Set(
-			requestedEnvVars.map((v) => (v.endsWith('?') ? v.slice(0, -1) : v)),
-		);
-		const providers: string[] = [];
-		for (const [name, vars] of this.linkVarsByName) {
-			if (vars.some((v) => requested.has(v))) providers.push(name);
-		}
-		return providers;
-	}
-
-	/**
-	 * Checks every requested variable against the available set. Variables
-	 * ending in `?` are optional and never reported as invalid. Invalid
-	 * variables come back with their nearest available matches.
-	 */
-	validate(requestedEnvVars: readonly string[]): ValidationResult {
-		const invalidVars = requestedEnvVars.filter((envVar) => {
-			if (envVar.endsWith('?')) return false;
-			return !this.availableSet.has(envVar);
-		});
-
-		const suggestions: Record<string, string[]> = {};
-		for (const envVar of invalidVars) {
-			const matches = suggestionsFor(envVar, this.availableVars);
-			if (matches.length) suggestions[envVar] = matches;
-		}
-
-		return {
-			valid: invalidVars.length === 0,
-			invalidVars,
-			availableVars: this.availableVars,
-			suggestions,
-		};
-	}
-
-	/**
-	 * Asserts that every requested variable is available, throwing an
-	 * {@link EnvValidationError} otherwise. Intended to run in a construct's
-	 * constructor so a misconfigured `sst.config.ts` fails at synth time, before
-	 * any AWS call.
-	 */
-	assert(requestedEnvVars: readonly string[]): void {
-		const { valid, invalidVars, suggestions } = this.validate(requestedEnvVars);
-
-		if (!valid) {
-			throw new EnvValidationError({
-				missing: invalidVars,
-				available: this.availableVars,
-				linkVars: this.linkVars,
-				suggestions,
-				context: this.context,
-			});
-		}
-	}
-
-	/**
-	 * Whether a single variable is available. Does not treat a trailing `?` as
-	 * optional — pass the bare name.
-	 */
-	has(envVar: string): boolean {
-		return this.availableSet.has(envVar);
-	}
-}

package/src/SstEnvironmentBuilder.ts

@@ -1,343 +0,0 @@
-import {
-	EnvironmentBuilder,
-	type EnvironmentBuilderOptions,
-	type EnvironmentResolver,
-	type EnvRecord,
-	type InputValue,
-	type Resolvers,
-} from './EnvironmentBuilder';
-
-/**
- * Enumeration of supported SST (Serverless Stack Toolkit) resource types.
- * Used to identify and process different AWS and SST resources.
- */
-export enum ResourceType {
-	// Legacy format (dot notation)
-	ApiGatewayV2 = 'sst.aws.ApiGatewayV2',
-	Postgres = 'sst.aws.Postgres',
-	Function = 'sst.aws.Function',
-	Bucket = 'sst.aws.Bucket',
-	Vpc = 'sst.aws.Vpc',
-	Secret = 'sst.sst.Secret',
-	Dynamo = 'sst.aws.Dynamo',
-	Queue = 'sst.aws.Queue',
-
-	// Modern format (colon notation)
-	SSTSecret = 'sst:sst:Secret',
-	SSTFunction = 'sst:sst:Function',
-	SSTApiGatewayV2 = 'sst:aws:ApiGatewayV2',
-	SSTPostgres = 'sst:aws:Postgres',
-	SSTBucket = 'sst:aws:Bucket',
-	SnsTopic = 'sst:aws:SnsTopic',
-	SSTDynamo = 'sst:aws:Dynamo',
-	SSTQueue = 'sst:aws:Queue',
-}
-
-/**
- * AWS API Gateway V2 resource type.
- * Represents an HTTP/WebSocket API.
- */
-export type ApiGatewayV2 = {
-	type: ResourceType.ApiGatewayV2 | ResourceType.SSTApiGatewayV2;
-	url: string;
-};
-
-/**
- * PostgreSQL database resource type.
- * Contains all connection details needed to connect to the database.
- */
-export type Postgres = {
-	type: ResourceType.Postgres | ResourceType.SSTPostgres;
-	database: string;
-	host: string;
-	password: string;
-	port: number;
-	username: string;
-};
-
-/**
- * AWS Lambda Function resource type.
- */
-export type Function = {
-	type: ResourceType.Function | ResourceType.SSTFunction;
-	name: string;
-};
-
-/**
- * AWS S3 Bucket resource type.
- */
-export type Bucket = {
-	type: ResourceType.Bucket | ResourceType.SSTBucket;
-	name: string;
-};
-
-/**
- * AWS VPC (Virtual Private Cloud) resource type.
- */
-export type Vpc = {
-	type: ResourceType.Vpc;
-	bastion: string;
-};
-
-/**
- * Secret resource type for storing sensitive values.
- */
-export type Secret = {
-	type: ResourceType.Secret | ResourceType.SSTSecret;
-	value: string;
-};
-
-/**
- * AWS SNS Topic resource type.
- */
-export type SnsTopic = {
-	type: ResourceType.SnsTopic;
-	arn: string;
-};
-
-/**
- * AWS SQS Queue resource type.
- */
-export type Queue = {
-	type: ResourceType.Queue | ResourceType.SSTQueue;
-	url: string;
-	arn: string;
-};
-
-/**
- * AWS DynamoDB Table resource type.
- */
-export type Dynamo = {
-	type: ResourceType.Dynamo | ResourceType.SSTDynamo;
-	name: string;
-};
-
-/**
- * Union type of all supported SST resource types.
- */
-export type SstResource =
-	| ApiGatewayV2
-	| Postgres
-	| Function
-	| Bucket
-	| Vpc
-	| Secret
-	| SnsTopic
-	| Queue
-	| Dynamo;
-
-// Value types without the `type` key (for resolver parameters)
-type SecretValue = Omit<Secret, 'type'>;
-type PostgresValue = Omit<Postgres, 'type'>;
-type BucketValue = Omit<Bucket, 'type'>;
-type SnsTopicValue = Omit<SnsTopic, 'type'>;
-type QueueValue = Omit<Queue, 'type'>;
-type DynamoValue = Omit<Dynamo, 'type'>;
-
-/**
- * Function type for processing a specific resource type into environment variables.
- *
- * @template K - The specific resource type (without `type` key)
- * @param name - The resource name
- * @param value - The resource value (without `type` key)
- * @returns Object mapping environment variable names to values
- */
-export type ResourceProcessor<K> = (name: string, value: K) => EnvRecord;
-
-// SST Resource Resolvers (receive values without `type` key)
-
-const secretResolver = (name: string, value: SecretValue) => ({
-	[name]: value.value,
-});
-
-const postgresResolver = (key: string, value: PostgresValue) => ({
-	[`${key}Name`]: value.database,
-	[`${key}Host`]: value.host,
-	[`${key}Password`]: value.password,
-	[`${key}Port`]: value.port,
-	[`${key}Username`]: value.username,
-	[`${key}Url`]: `postgresql://${encodeURIComponent(value.username)}:${encodeURIComponent(value.password)}@${value.host}:${value.port}/${value.database}`,
-});
-
-const bucketResolver = (name: string, value: BucketValue) => ({
-	[`${name}Name`]: value.name,
-});
-
-const topicResolver = (name: string, value: SnsTopicValue) => ({
-	[`${name}Arn`]: value.arn,
-	// A publisher connection string for `@geekmidas/events` (SNS); region is
-	// resolved from the ARN / AWS_REGION at runtime.
-	[`${name}PublisherConnectionString`]: `sns://?topicArn=${encodeURIComponent(value.arn)}`,
-});
-
-const queueResolver = (name: string, value: QueueValue) => ({
-	[`${name}Url`]: value.url,
-	[`${name}Arn`]: value.arn,
-	// A publisher connection string for `@geekmidas/events` (SQS); region is
-	// resolved from the URL / AWS_REGION at runtime.
-	[`${name}PublisherConnectionString`]: `sqs://?queueUrl=${encodeURIComponent(value.url)}`,
-});
-
-const dynamoResolver = (name: string, value: DynamoValue) => ({
-	[`${name}Name`]: value.name,
-});
-
-const noopResolver = () => ({});
-
-/**
- * Pre-configured resolvers for all SST resource types.
- */
-export const sstResolvers: Resolvers = {
-	// Legacy format
-	[ResourceType.ApiGatewayV2]: noopResolver,
-	[ResourceType.Function]: noopResolver,
-	[ResourceType.Vpc]: noopResolver,
-	[ResourceType.Secret]: secretResolver,
-	[ResourceType.Postgres]: postgresResolver,
-	[ResourceType.Bucket]: bucketResolver,
-	[ResourceType.Dynamo]: dynamoResolver,
-	[ResourceType.Queue]: queueResolver,
-
-	// Modern format
-	[ResourceType.SSTSecret]: secretResolver,
-	[ResourceType.SSTBucket]: bucketResolver,
-	[ResourceType.SSTFunction]: noopResolver,
-	[ResourceType.SSTPostgres]: postgresResolver,
-	[ResourceType.SSTApiGatewayV2]: noopResolver,
-	[ResourceType.SnsTopic]: topicResolver,
-	[ResourceType.SSTDynamo]: dynamoResolver,
-	[ResourceType.SSTQueue]: queueResolver,
-};
-
-/**
- * All known SST resource type strings.
- */
-type SstResourceTypeString = `${ResourceType}`;
-
-/**
- * Extracts the `type` string value from an input value.
- */
-type ExtractType<T> = T extends { type: infer U extends string } ? U : never;
-
-/**
- * Removes the `type` key from an object type.
- */
-type OmitType<T> = T extends { type: string } ? Omit<T, 'type'> : never;
-
-/**
- * Extracts all unique `type` values from a record (excluding plain strings).
- */
-type AllTypeValues<TRecord extends Record<string, InputValue>> = {
-	[K in keyof TRecord]: ExtractType<TRecord[K]>;
-}[keyof TRecord];
-
-/**
- * Extracts only the custom (non-SST) type values from a record.
- */
-type CustomTypeValues<TRecord extends Record<string, InputValue>> = Exclude<
-	AllTypeValues<TRecord>,
-	SstResourceTypeString
->;
-
-/**
- * For a given type value, finds the corresponding value type (without `type` key).
- */
-type ValueForType<
-	TRecord extends Record<string, InputValue>,
-	TType extends string,
-> = {
-	[K in keyof TRecord]: TRecord[K] extends { type: TType }
-		? OmitType<TRecord[K]>
-		: never;
-}[keyof TRecord];
-
-/**
- * Generates typed resolvers for custom (non-SST) types in the input record.
- */
-type CustomResolvers<TRecord extends Record<string, InputValue>> =
-	CustomTypeValues<TRecord> extends never
-		? Resolvers | undefined
-		: {
-				[TType in CustomTypeValues<TRecord>]: EnvironmentResolver<
-					ValueForType<TRecord, TType>
-				>;
-			};
-
-/**
- * SST-specific environment builder with built-in resolvers for all known
- * SST resource types.
- *
- * Wraps the generic EnvironmentBuilder with pre-configured SST resolvers.
- *
- * @template TRecord - The input record type for type inference
- *
- * @example
- * ```typescript
- * const env = new SstEnvironmentBuilder({
- *   database: { type: 'sst:aws:Postgres', host: '...', ... },
- *   apiKey: { type: 'sst:sst:Secret', value: 'secret' },
- *   appName: 'my-app',
- * }).build();
- *
- * // With custom resolvers (typed based on input)
- * const env = new SstEnvironmentBuilder(
- *   {
- *     database: postgresResource,
- *     custom: { type: 'my-custom' as const, data: 'foo' },
- *   },
- *   {
- *     // TypeScript requires 'my-custom' resolver with typed value
- *     'my-custom': (key, value) => ({ [`${key}Data`]: value.data }),
- *   }
- * ).build();
- * ```
- */
-export class SstEnvironmentBuilder<
-	TRecord extends Record<string, SstResource | InputValue | string>,
-> {
-	private readonly builder: EnvironmentBuilder<
-		Record<string, InputValue>,
-		Resolvers
-	>;
-
-	/**
-	 * Create a new SST environment builder.
-	 *
-	 * @param record - Object containing SST resources, custom resources, and/or string values
-	 * @param additionalResolvers - Optional custom resolvers (typed based on custom types in record)
-	 * @param options - Optional configuration options
-	 */
-	constructor(
-		record: TRecord,
-		additionalResolvers?: CustomResolvers<TRecord>,
-		options?: EnvironmentBuilderOptions,
-	) {
-		// Merge resolvers with custom ones taking precedence
-		const mergedResolvers: Resolvers = additionalResolvers
-			? { ...sstResolvers, ...additionalResolvers }
-			: sstResolvers;
-
-		this.builder = new EnvironmentBuilder(
-			record as Record<string, InputValue>,
-			mergedResolvers,
-			options,
-		);
-	}
-
-	/**
-	 * Build environment variables from the input record.
-	 *
-	 * @returns A record of environment variables
-	 */
-	build(): EnvRecord {
-		return this.builder.build();
-	}
-}
-
-export type {
-	EnvironmentBuilderOptions,
-	EnvRecord,
-	EnvValue,
-} from './EnvironmentBuilder';
-// Re-export useful types
-export { environmentCase } from './EnvironmentBuilder';