@geekmidas/envkit 0.0.7 → 0.1.0

package/src/__tests__/SnifferEnvironmentParser.spec.ts

@@ -0,0 +1,332 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { SnifferEnvironmentParser } from '../SnifferEnvironmentParser';
+
+describe('SnifferEnvironmentParser', () => {
+  describe('Environment variable tracking', () => {
+    it('should track accessed environment variables', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        appName: get('APP_NAME').string(),
+        port: get('PORT').string().transform(Number),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['APP_NAME', 'PORT']);
+    });
+
+    it('should track variables in nested configurations', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        database: {
+          host: get('DB_HOST').string(),
+          port: get('DB_PORT').string().transform(Number),
+        },
+        api: {
+          key: get('API_KEY').string(),
+        },
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['API_KEY', 'DB_HOST', 'DB_PORT']);
+    });
+
+    it('should return sorted environment variable names', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        zValue: get('Z_VALUE').string(),
+        aValue: get('A_VALUE').string(),
+        mValue: get('M_VALUE').string(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['A_VALUE', 'M_VALUE', 'Z_VALUE']);
+    });
+
+    it('should deduplicate environment variable names', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        value1: get('SHARED_VAR').string(),
+        value2: get('SHARED_VAR').string(),
+        value3: get('SHARED_VAR').string(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['SHARED_VAR']);
+    });
+
+    it('should track variables accessed through coerce', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        workers: get('NUM_WORKERS').coerce.number(),
+        timeout: get('TIMEOUT').coerce.number(),
+      }));
+
+      const envVars = sniffer.getEnvironmentVariables();
+      expect(envVars).toEqual(['NUM_WORKERS', 'TIMEOUT']);
+    });
+  });
+
+  describe('Mock value parsing', () => {
+    it('should never throw when parsing - returns mock values', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer.create((get) => ({
+        required: get('REQUIRED_VAR').string(),
+        alsoRequired: get('ALSO_REQUIRED').string(),
+      }));
+
+      // Should not throw even though env vars are not set
+      expect(() => config.parse()).not.toThrow();
+    });
+
+    it('should return empty string for string schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('STRING_VAR').string(),
+        }))
+        .parse();
+
+      expect(config.value).toBe('');
+    });
+
+    it('should return 0 for number schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('NUMBER_VAR').coerce.number(),
+        }))
+        .parse();
+
+      expect(config.value).toBe(0);
+    });
+
+    it('should return false for boolean schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('BOOL_VAR').coerce.boolean(),
+        }))
+        .parse();
+
+      expect(config.value).toBe(false);
+    });
+
+    it('should return empty array for array schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('ARRAY_VAR').array(z.string()),
+        }))
+        .parse();
+
+      expect(config.value).toEqual([]);
+    });
+
+    it('should return undefined for optional schemas', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          value: get('OPTIONAL_VAR').string().optional(),
+        }))
+        .parse();
+
+      expect(config.value).toBeUndefined();
+    });
+
+    it('should handle nested configurations', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const config = sniffer
+        .create((get) => ({
+          database: {
+            host: get('DB_HOST').string(),
+            port: get('DB_PORT').coerce.number(),
+          },
+          cache: {
+            enabled: get('CACHE_ENABLED').coerce.boolean(),
+          },
+        }))
+        .parse();
+
+      expect(config).toEqual({
+        database: {
+          host: '',
+          port: 0,
+        },
+        cache: {
+          enabled: false,
+        },
+      });
+    });
+
+    it('should track variables with transforms', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        origins: get('ALLOWED_ORIGINS')
+          .string()
+          .transform((v) => v.split(',')),
+        port: get('PORT').string().transform(Number),
+      }));
+
+      // Should track the env vars even with transforms
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'ALLOWED_ORIGINS',
+        'PORT',
+      ]);
+    });
+  });
+
+  describe('Service registration simulation', () => {
+    it('should allow simulated service registration to succeed', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      // Simulate a service that would normally fail without env vars
+      const mockService = {
+        serviceName: 'database' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          const config = envParser
+            .create((get) => ({
+              url: get('DATABASE_URL').string(),
+              poolSize: get('DB_POOL_SIZE').coerce.number(),
+            }))
+            .parse();
+
+          // Service uses parsed values to create connection
+          return { url: config.url, poolSize: config.poolSize };
+        },
+      };
+
+      // Should not throw
+      expect(() => mockService.register(sniffer)).not.toThrow();
+
+      // Should have tracked the env vars
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'DATABASE_URL',
+        'DB_POOL_SIZE',
+      ]);
+    });
+
+    it('should work with multiple services', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const databaseService = {
+        serviceName: 'db' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          return envParser
+            .create((get) => ({
+              host: get('DB_HOST').string(),
+              port: get('DB_PORT').coerce.number(),
+            }))
+            .parse();
+        },
+      };
+
+      const cacheService = {
+        serviceName: 'cache' as const,
+        register(envParser: SnifferEnvironmentParser) {
+          return envParser
+            .create((get) => ({
+              url: get('REDIS_URL').string(),
+              ttl: get('CACHE_TTL').coerce.number(),
+            }))
+            .parse();
+        },
+      };
+
+      // Register both services
+      databaseService.register(sniffer);
+      cacheService.register(sniffer);
+
+      // Should have tracked all env vars from both services
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'CACHE_TTL',
+        'DB_HOST',
+        'DB_PORT',
+        'REDIS_URL',
+      ]);
+    });
+
+    it('should handle async service registration', async () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      const asyncService = {
+        serviceName: 'async' as const,
+        async register(envParser: SnifferEnvironmentParser) {
+          const config = envParser
+            .create((get) => ({
+              apiKey: get('API_KEY').string(),
+              endpoint: get('API_ENDPOINT').string(),
+            }))
+            .parse();
+
+          // Simulate async initialization
+          await Promise.resolve();
+          return config;
+        },
+      };
+
+      await expect(asyncService.register(sniffer)).resolves.not.toThrow();
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'API_ENDPOINT',
+        'API_KEY',
+      ]);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should return empty array when no variables accessed', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create(() => ({}));
+
+      expect(sniffer.getEnvironmentVariables()).toEqual([]);
+    });
+
+    it('should handle deeply nested objects', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        level1: {
+          level2: {
+            level3: {
+              value: get('DEEP_VALUE').string(),
+            },
+          },
+        },
+      }));
+
+      expect(sniffer.getEnvironmentVariables()).toEqual(['DEEP_VALUE']);
+    });
+
+    it('should handle multiple create calls', () => {
+      const sniffer = new SnifferEnvironmentParser();
+
+      sniffer.create((get) => ({
+        first: get('FIRST_VAR').string(),
+      }));
+
+      sniffer.create((get) => ({
+        second: get('SECOND_VAR').string(),
+      }));
+
+      // Should accumulate vars from both create calls
+      expect(sniffer.getEnvironmentVariables()).toEqual([
+        'FIRST_VAR',
+        'SECOND_VAR',
+      ]);
+    });
+  });
+});

package/src/__tests__/SstEnvironmentBuilder.spec.ts

@@ -0,0 +1,373 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  type Bucket,
+  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',
+      });
+    });
+
+    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',
+      });
+    });
+  });
+
+  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',
+      });
+    });
+  });
+
+  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',
+        JWT_SECRET: 'jwt-secret',
+        UPLOADS_NAME: 'uploads-bucket',
+        EVENTS_ARN: 'arn:aws:sns:us-east-1:123456789:events',
+        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 warn for unknown resource types', () => {
+      const consoleWarnSpy = vi
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {});
+
+      const unknownResource = {
+        type: 'unknown.resource.Type',
+        value: 'something',
+      };
+
+      const env = new SstEnvironmentBuilder({
+        unknown: unknownResource,
+      }).build();
+
+      expect(env).toEqual({});
+      expect(consoleWarnSpy).toHaveBeenCalled();
+
+      consoleWarnSpy.mockRestore();
+    });
+
+    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');
+    });
+  });
+
+  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');
+    });
+  });
+});

package/src/__tests__/sst.spec.ts

@@ -321,7 +321,7 @@ describe('sst', () => {
 
         expect(result).toEqual({});
         expect(consoleWarnSpy).toHaveBeenCalledWith(
-          'No processor found for resource type: ',
+          'No resolver found for key "unknown":',
           { value: unknownResource },
         );