@geekmidas/envkit 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/SstEnvValidator.spec.ts

@@ -1,236 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ResourceType } from '../SstEnvironmentBuilder';
-import {
-	EnvValidationError,
-	EnvValidator,
-	platformEnvVars,
-	resolveEnvKeys,
-} from '../sst';
-
-describe('SstEnvValidator', () => {
-	describe('resolveEnvKeys', () => {
-		it('derives all keys a Postgres link produces', () => {
-			expect(resolveEnvKeys({ db: { type: ResourceType.Postgres } })).toEqual([
-				'DB_NAME',
-				'DB_HOST',
-				'DB_PASSWORD',
-				'DB_PORT',
-				'DB_USERNAME',
-				'DB_URL',
-			]);
-		});
-
-		it('derives the bare key a Secret link produces', () => {
-			expect(resolveEnvKeys({ apiKey: { type: ResourceType.Secret } })).toEqual(
-				['API_KEY'],
-			);
-		});
-
-		it('derives the suffixed key a Bucket link produces', () => {
-			expect(
-				resolveEnvKeys({ uploads: { type: ResourceType.Bucket } }),
-			).toEqual(['UPLOADS_NAME']);
-		});
-
-		it('derives queue keys incl. the publisher connection string', () => {
-			expect(resolveEnvKeys({ orders: { type: ResourceType.Queue } })).toEqual([
-				'ORDERS_URL',
-				'ORDERS_ARN',
-				'ORDERS_PUBLISHER_CONNECTION_STRING',
-			]);
-		});
-
-		it('derives topic keys incl. the publisher connection string', () => {
-			expect(
-				resolveEnvKeys({ events: { type: ResourceType.SnsTopic } }),
-			).toEqual(['EVENTS_ARN', 'EVENTS_PUBLISHER_CONNECTION_STRING']);
-		});
-
-		it('derives no keys for noop resource types', () => {
-			expect(
-				resolveEnvKeys({
-					fn: { type: ResourceType.Function },
-					api: { type: ResourceType.ApiGatewayV2 },
-					net: { type: ResourceType.Vpc },
-				}),
-			).toEqual([]);
-		});
-
-		it('passes plain string entries through as a single env-cased key', () => {
-			expect(resolveEnvKeys({ logLevel: 'debug' })).toEqual(['LOG_LEVEL']);
-		});
-
-		it('does not read resource values (keys only)', () => {
-			const withValues = resolveEnvKeys({
-				db: {
-					type: ResourceType.Postgres,
-					database: 'app',
-					host: 'localhost',
-					password: 'secret',
-					port: 5432,
-					username: 'user',
-				},
-			});
-			expect(withValues).toEqual(
-				resolveEnvKeys({ db: { type: ResourceType.Postgres } }),
-			);
-		});
-
-		it('merges keys across multiple links', () => {
-			const keys = resolveEnvKeys({
-				db: { type: ResourceType.Postgres },
-				cache: { type: ResourceType.Bucket },
-			});
-			expect(keys).toContain('DB_HOST');
-			expect(keys).toContain('CACHE_NAME');
-		});
-	});
-
-	describe('platform whitelists', () => {
-		it('exposes per-platform runtime vars that differ', () => {
-			expect(platformEnvVars('aws')).toContain('AWS_REGION');
-			expect(platformEnvVars('gcp')).toContain('GOOGLE_CLOUD_PROJECT');
-			expect(platformEnvVars('gcp')).not.toContain('AWS_REGION');
-		});
-
-		it('assumes no platform whitelist by default', () => {
-			const validator = new EnvValidator({
-				db: { type: ResourceType.Postgres },
-			});
-			expect(validator.has('AWS_REGION')).toBe(false);
-		});
-
-		it('trusts the AWS runtime vars only when platform: aws is set', () => {
-			const validator = new EnvValidator(
-				{ db: { type: ResourceType.Postgres } },
-				{ platform: 'aws' },
-			);
-			expect(validator.has('AWS_REGION')).toBe(true);
-			expect(validator.validate(['DB_HOST', 'AWS_REGION']).valid).toBe(true);
-		});
-
-		it('does not trust AWS vars when targeting gcp', () => {
-			const validator = new EnvValidator(
-				{ db: { type: ResourceType.Postgres } },
-				{ platform: 'gcp' },
-			);
-			expect(validator.has('AWS_REGION')).toBe(false);
-			expect(validator.has('GOOGLE_CLOUD_PROJECT')).toBe(true);
-		});
-	});
-
-	describe('EnvValidator', () => {
-		const links = {
-			db: { type: ResourceType.Postgres },
-			apiKey: { type: ResourceType.Secret },
-		} as const;
-
-		it('exposes available vars from links', () => {
-			const validator = new EnvValidator(links);
-			expect(validator.has('DB_HOST')).toBe(true);
-			expect(validator.has('API_KEY')).toBe(true);
-			expect(validator.has('NOT_THERE')).toBe(false);
-		});
-
-		it('validate() reports missing variables', () => {
-			const validator = new EnvValidator(links);
-			const result = validator.validate(['DB_HOST', 'MISSING_ONE']);
-			expect(result.valid).toBe(false);
-			expect(result.invalidVars).toEqual(['MISSING_ONE']);
-		});
-
-		it('validate() passes when every required var is available', () => {
-			const validator = new EnvValidator(links);
-			expect(validator.validate(['DB_HOST', 'DB_URL', 'API_KEY']).valid).toBe(
-				true,
-			);
-		});
-
-		it('treats `?`-suffixed variables as optional', () => {
-			const validator = new EnvValidator(links);
-			expect(validator.validate(['DB_HOST', 'SENTRY_DSN?']).valid).toBe(true);
-		});
-
-		it('honours an additional whitelist (e.g. explicit environment keys)', () => {
-			const validator = new EnvValidator(links, { whitelist: ['APP_NAME'] });
-			expect(validator.validate(['DB_HOST', 'APP_NAME']).valid).toBe(true);
-		});
-	});
-
-	describe('getProvidersForEnvVars (least-privilege filtering)', () => {
-		const validator = new EnvValidator({
-			db: { type: ResourceType.Postgres },
-			uploads: { type: ResourceType.Bucket },
-			apiKey: { type: ResourceType.Secret },
-		});
-
-		it('returns only the links that provide a requested var', () => {
-			expect(validator.getProvidersForEnvVars(['DB_HOST'])).toEqual(['db']);
-		});
-
-		it('returns multiple providers when several match', () => {
-			const providers = validator.getProvidersForEnvVars([
-				'DB_URL',
-				'UPLOADS_NAME',
-			]);
-			expect(providers).toEqual(['db', 'uploads']);
-		});
-
-		it('ignores optional `?` markers', () => {
-			expect(validator.getProvidersForEnvVars(['API_KEY?'])).toEqual([
-				'apiKey',
-			]);
-		});
-
-		it('returns nothing when no link provides the var', () => {
-			expect(validator.getProvidersForEnvVars(['AWS_REGION'])).toEqual([]);
-		});
-	});
-
-	describe('did-you-mean suggestions', () => {
-		const validator = new EnvValidator({
-			db: { type: ResourceType.Postgres },
-			redis: { type: ResourceType.Secret },
-		});
-
-		it('suggests a renamed match (DATABASE_URL -> DB_URL)', () => {
-			const { suggestions } = validator.validate(['DATABASE_URL']);
-			expect(suggestions.DATABASE_URL).toContain('DB_URL');
-		});
-
-		it('suggests a near-typo match (DB_HSOT -> DB_HOST)', () => {
-			const { suggestions } = validator.validate(['DB_HSOT']);
-			expect(suggestions.DB_HSOT).toContain('DB_HOST');
-		});
-
-		it('offers no suggestion for an unrelated variable', () => {
-			const { suggestions } = validator.validate(['STRIPE_SECRET_KEY']);
-			expect(suggestions.STRIPE_SECRET_KEY).toBeUndefined();
-		});
-	});
-
-	describe('EnvValidationError', () => {
-		const links = { db: { type: ResourceType.Postgres } } as const;
-
-		it('assert() throws an EnvValidationError with structured fields', () => {
-			const validator = new EnvValidator(links, { context: 'orders-fn' });
-			try {
-				validator.assert(['DATABASE_URL', 'DB_HOST']);
-				expect.unreachable('assert should have thrown');
-			} catch (error) {
-				expect(error).toBeInstanceOf(EnvValidationError);
-				const e = error as EnvValidationError;
-				expect(e.missing).toEqual(['DATABASE_URL']);
-				expect(e.context).toBe('orders-fn');
-				expect(e.suggestions.DATABASE_URL).toContain('DB_URL');
-				expect(e.message).toContain("'orders-fn'");
-				expect(e.message).toContain('did you mean DB_URL?');
-			}
-		});
-
-		it('assert() does not throw when all required vars are available', () => {
-			const validator = new EnvValidator(links);
-			expect(() => validator.assert(['DB_HOST', 'DB_URL'])).not.toThrow();
-		});
-	});
-});

package/src/__tests__/SstEnvironmentBuilder.spec.ts

@@ -1,397 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-	type Bucket,
-	type Dynamo,
-	type Postgres,
-	ResourceType,
-	type Secret,
-	type SnsTopic,
-	SstEnvironmentBuilder,
-	sstResolvers,
-} from '../SstEnvironmentBuilder';
-
-describe('SstEnvironmentBuilder', () => {
-	describe('basic functionality', () => {
-		it('should pass through plain string values with key transformation', () => {
-			const env = new SstEnvironmentBuilder({
-				appName: 'my-app',
-				nodeEnv: 'production',
-			}).build();
-
-			expect(env).toEqual({
-				APP_NAME: 'my-app',
-				NODE_ENV: 'production',
-			});
-		});
-
-		it('should handle empty input', () => {
-			const env = new SstEnvironmentBuilder({}).build();
-			expect(env).toEqual({});
-		});
-	});
-
-	describe('Secret resource', () => {
-		it('should process Secret resource correctly', () => {
-			const secret: Secret = {
-				type: ResourceType.Secret,
-				value: 'super-secret-value',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				mySecret: secret,
-			}).build();
-
-			expect(env).toEqual({
-				MY_SECRET: 'super-secret-value',
-			});
-		});
-
-		it('should process SSTSecret resource correctly', () => {
-			const secret: Secret = {
-				type: ResourceType.SSTSecret,
-				value: 'another-secret',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				appSecret: secret,
-			}).build();
-
-			expect(env).toEqual({
-				APP_SECRET: 'another-secret',
-			});
-		});
-	});
-
-	describe('Postgres resource', () => {
-		it('should process Postgres resource correctly', () => {
-			const postgres: Postgres = {
-				type: ResourceType.Postgres,
-				database: 'myapp',
-				host: 'localhost',
-				password: 'password123',
-				port: 5432,
-				username: 'postgres',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				database: postgres,
-			}).build();
-
-			expect(env).toEqual({
-				DATABASE_NAME: 'myapp',
-				DATABASE_HOST: 'localhost',
-				DATABASE_PASSWORD: 'password123',
-				DATABASE_PORT: 5432,
-				DATABASE_USERNAME: 'postgres',
-				DATABASE_URL: 'postgresql://postgres:password123@localhost:5432/myapp',
-			});
-		});
-
-		it('should process SSTPostgres resource correctly', () => {
-			const postgres: Postgres = {
-				type: ResourceType.SSTPostgres,
-				database: 'prod_db',
-				host: 'prod.example.com',
-				password: 'prod-password',
-				port: 5433,
-				username: 'prod_user',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				mainDb: postgres,
-			}).build();
-
-			expect(env).toEqual({
-				MAIN_DB_NAME: 'prod_db',
-				MAIN_DB_HOST: 'prod.example.com',
-				MAIN_DB_PASSWORD: 'prod-password',
-				MAIN_DB_PORT: 5433,
-				MAIN_DB_USERNAME: 'prod_user',
-				MAIN_DB_URL:
-					'postgresql://prod_user:prod-password@prod.example.com:5433/prod_db',
-			});
-		});
-	});
-
-	describe('Bucket resource', () => {
-		it('should process Bucket resource correctly', () => {
-			const bucket: Bucket = {
-				type: ResourceType.Bucket,
-				name: 'my-s3-bucket',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				uploadBucket: bucket,
-			}).build();
-
-			expect(env).toEqual({
-				UPLOAD_BUCKET_NAME: 'my-s3-bucket',
-			});
-		});
-
-		it('should process SSTBucket resource correctly', () => {
-			const bucket: Bucket = {
-				type: ResourceType.SSTBucket,
-				name: 'assets-bucket-prod',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				assetStorage: bucket,
-			}).build();
-
-			expect(env).toEqual({
-				ASSET_STORAGE_NAME: 'assets-bucket-prod',
-			});
-		});
-	});
-
-	describe('SnsTopic resource', () => {
-		it('should process SnsTopic resource correctly', () => {
-			const topic: SnsTopic = {
-				type: ResourceType.SnsTopic,
-				arn: 'arn:aws:sns:us-east-1:123456789:my-topic',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				eventsTopic: topic,
-			}).build();
-
-			expect(env).toEqual({
-				EVENTS_TOPIC_ARN: 'arn:aws:sns:us-east-1:123456789:my-topic',
-				EVENTS_TOPIC_PUBLISHER_CONNECTION_STRING:
-					'sns://?topicArn=arn%3Aaws%3Asns%3Aus-east-1%3A123456789%3Amy-topic',
-			});
-		});
-	});
-
-	describe('Dynamo resource', () => {
-		it('should process legacy Dynamo resource correctly', () => {
-			const dynamo: Dynamo = {
-				type: ResourceType.Dynamo,
-				name: 'my-dynamo-table',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				usersTable: dynamo,
-			}).build();
-
-			expect(env).toEqual({
-				USERS_TABLE_NAME: 'my-dynamo-table',
-			});
-		});
-
-		it('should process SSTDynamo resource correctly', () => {
-			const dynamo: Dynamo = {
-				type: ResourceType.SSTDynamo,
-				name: 'sessions-table-prod',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				sessionsTable: dynamo,
-			}).build();
-
-			expect(env).toEqual({
-				SESSIONS_TABLE_NAME: 'sessions-table-prod',
-			});
-		});
-	});
-
-	describe('noop resources', () => {
-		it('should not add environment variables for ApiGatewayV2', () => {
-			const env = new SstEnvironmentBuilder({
-				api: {
-					type: ResourceType.ApiGatewayV2,
-					url: 'https://api.example.com',
-				},
-			}).build();
-
-			expect(env).toEqual({});
-		});
-
-		it('should not add environment variables for Function', () => {
-			const env = new SstEnvironmentBuilder({
-				handler: {
-					type: ResourceType.Function,
-					name: 'my-lambda',
-				},
-			}).build();
-
-			expect(env).toEqual({});
-		});
-
-		it('should not add environment variables for Vpc', () => {
-			const env = new SstEnvironmentBuilder({
-				network: {
-					type: ResourceType.Vpc,
-					bastion: 'bastion-host',
-				},
-			}).build();
-
-			expect(env).toEqual({});
-		});
-	});
-
-	describe('mixed resources', () => {
-		it('should handle mix of strings and resources', () => {
-			const postgres: Postgres = {
-				type: ResourceType.Postgres,
-				database: 'app_db',
-				host: 'db.example.com',
-				password: 'db-pass',
-				port: 5432,
-				username: 'app_user',
-			};
-
-			const secret: Secret = {
-				type: ResourceType.Secret,
-				value: 'jwt-secret',
-			};
-
-			const bucket: Bucket = {
-				type: ResourceType.Bucket,
-				name: 'uploads-bucket',
-			};
-
-			const topic: SnsTopic = {
-				type: ResourceType.SnsTopic,
-				arn: 'arn:aws:sns:us-east-1:123456789:events',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				nodeEnv: 'production',
-				appName: 'My App',
-				database: postgres,
-				jwtSecret: secret,
-				uploads: bucket,
-				events: topic,
-				apiVersion: 'v2',
-			}).build();
-
-			expect(env).toEqual({
-				NODE_ENV: 'production',
-				APP_NAME: 'My App',
-				DATABASE_NAME: 'app_db',
-				DATABASE_HOST: 'db.example.com',
-				DATABASE_PASSWORD: 'db-pass',
-				DATABASE_PORT: 5432,
-				DATABASE_USERNAME: 'app_user',
-				DATABASE_URL:
-					'postgresql://app_user:db-pass@db.example.com:5432/app_db',
-				JWT_SECRET: 'jwt-secret',
-				UPLOADS_NAME: 'uploads-bucket',
-				EVENTS_ARN: 'arn:aws:sns:us-east-1:123456789:events',
-				EVENTS_PUBLISHER_CONNECTION_STRING:
-					'sns://?topicArn=arn%3Aaws%3Asns%3Aus-east-1%3A123456789%3Aevents',
-				API_VERSION: 'v2',
-			});
-		});
-	});
-
-	describe('additional resolvers', () => {
-		it('should allow custom resolvers', () => {
-			const env = new SstEnvironmentBuilder(
-				{
-					custom: { type: 'my-custom-type' as const, data: 'custom-data' },
-					secret: { type: ResourceType.Secret, value: 'secret-value' },
-				},
-				{
-					'my-custom-type': (key: string, value: { data: string }) => ({
-						[`${key}Data`]: value.data,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				CUSTOM_DATA: 'custom-data',
-				SECRET: 'secret-value',
-			});
-		});
-
-		it('should allow custom resolvers to override built-in resolvers', () => {
-			const env = new SstEnvironmentBuilder(
-				{
-					mySecret: { type: ResourceType.Secret, value: 'original-value' },
-				},
-				{
-					[ResourceType.Secret]: (
-						key: string,
-						value: { type: string; value: string },
-					) => ({
-						[`${key}Custom`]: `modified-${value.value}`,
-					}),
-				},
-			).build();
-
-			expect(env).toEqual({
-				MY_SECRET_CUSTOM: 'modified-original-value',
-			});
-		});
-	});
-
-	describe('edge cases', () => {
-		it('should handle resources with special characters in keys', () => {
-			const secret: Secret = {
-				type: ResourceType.Secret,
-				value: 'value',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				'my-secret-key': secret,
-				'another.secret': secret,
-			}).build();
-
-			expect(env).toEqual({
-				MY_SECRET_KEY: 'value',
-				ANOTHER_SECRET: 'value',
-			});
-		});
-
-		it('should preserve numeric values for postgres port', () => {
-			const postgres: Postgres = {
-				type: ResourceType.Postgres,
-				database: 'test',
-				host: 'localhost',
-				password: 'pass',
-				port: 5432,
-				username: 'user',
-			};
-
-			const env = new SstEnvironmentBuilder({
-				db: postgres,
-			}).build();
-
-			expect(env.DB_PORT).toBe(5432);
-			expect(typeof env.DB_PORT).toBe('number');
-		});
-	});
-
-	describe('sstResolvers export', () => {
-		it('should export pre-configured SST resolvers', () => {
-			expect(sstResolvers).toBeDefined();
-			expect(typeof sstResolvers[ResourceType.Secret]).toBe('function');
-			expect(typeof sstResolvers[ResourceType.Postgres]).toBe('function');
-			expect(typeof sstResolvers[ResourceType.Bucket]).toBe('function');
-			expect(typeof sstResolvers[ResourceType.SnsTopic]).toBe('function');
-			expect(typeof sstResolvers[ResourceType.SSTDynamo]).toBe('function');
-		});
-	});
-
-	describe('ResourceType enum', () => {
-		it('should have all expected resource types', () => {
-			expect(ResourceType.ApiGatewayV2).toBe('sst.aws.ApiGatewayV2');
-			expect(ResourceType.Postgres).toBe('sst.aws.Postgres');
-			expect(ResourceType.Function).toBe('sst.aws.Function');
-			expect(ResourceType.Bucket).toBe('sst.aws.Bucket');
-			expect(ResourceType.Vpc).toBe('sst.aws.Vpc');
-			expect(ResourceType.Secret).toBe('sst.sst.Secret');
-			expect(ResourceType.SSTSecret).toBe('sst:sst:Secret');
-			expect(ResourceType.SSTFunction).toBe('sst:sst:Function');
-			expect(ResourceType.SSTApiGatewayV2).toBe('sst:aws:ApiGatewayV2');
-			expect(ResourceType.SSTPostgres).toBe('sst:aws:Postgres');
-			expect(ResourceType.SSTBucket).toBe('sst:aws:Bucket');
-			expect(ResourceType.SnsTopic).toBe('sst:aws:SnsTopic');
-			expect(ResourceType.SSTDynamo).toBe('sst:aws:Dynamo');
-		});
-	});
-});