@geekmidas/envkit 0.0.8 → 0.1.0

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 },
         );
 

package/src/index.ts

@@ -1 +1,13 @@
 export { EnvironmentParser, ConfigParser } from './EnvironmentParser';
+export {
+  EnvironmentBuilder,
+  environmentCase,
+  type EnvRecord,
+  type EnvValue,
+  type EnvironmentResolver,
+  type Resolvers,
+  type EnvironmentBuilderOptions,
+  type InputValue,
+  type TypedInputValue,
+  type TypedResolvers,
+} from './EnvironmentBuilder';

package/src/sst.ts

@@ -1,114 +1,38 @@
-import snakecase from 'lodash.snakecase';
-
-/**
- * Converts a string to environment variable case format (UPPER_SNAKE_CASE).
- * Numbers following underscores are preserved without the underscore.
- *
- * @param name - The string to convert
- * @returns The converted string in environment variable format
- *
- * @example
- * environmentCase('myVariable') // 'MY_VARIABLE'
- * environmentCase('api_v2') // 'APIV2'
- */
-export function environmentCase(name: string) {
-  return snakecase(name)
-    .toUpperCase()
-    .replace(/_\d+/g, (r) => {
-      return r.replace('_', '');
-    });
-}
-
-/**
- * Enumeration of supported SST (Serverless Stack Toolkit) resource types.
- * Used to identify and process different AWS and SST resources.
- */
-export enum ResourceType {
-  ApiGatewayV2 = 'sst.aws.ApiGatewayV2',
-  Postgres = 'sst.aws.Postgres',
-  Function = 'sst.aws.Function',
-  Bucket = 'sst.aws.Bucket',
-  Vpc = 'sst.aws.Vpc',
-  Secret = 'sst.sst.Secret',
-  SSTSecret = 'sst:sst:Secret',
-  SSTFunction = 'sst:sst:Function',
-  SSTApiGatewayV2 = 'sst:aws:ApiGatewayV2',
-  SSTPostgres = 'sst:aws:Postgres',
-  SSTBucket = 'sst:aws:Bucket',
-}
-
-/**
- * Processes a Secret resource into environment variables.
- *
- * @param name - The resource name
- * @param value - The Secret resource
- * @returns Object with environment variable mappings
- */
-const secret = (name: string, value: Secret) => ({
-  [environmentCase(name)]: value.value,
-});
-/**
- * Processes a Postgres database resource into environment variables.
- * Creates multiple environment variables for database connection details.
- *
- * @param key - The resource key
- * @param value - The Postgres resource
- * @returns Object with database connection environment variables
- */
-const postgres = (key: string, value: Postgres) => {
-  const prefix = `${environmentCase(key)}`;
-  return {
-    [`${prefix}_NAME`]: value.database,
-    [`${prefix}_HOST`]: value.host,
-    [`${prefix}_PASSWORD`]: value.password,
-    [`${prefix}_PORT`]: value.port,
-    [`${prefix}_USERNAME`]: value.username,
-  };
-};
-
-/**
- * Processes a Bucket resource into environment variables.
- *
- * @param name - The resource name
- * @param value - The Bucket resource
- * @returns Object with bucket name environment variable
- */
-const bucket = (name: string, value: Bucket) => {
-  const prefix = `${environmentCase(name)}`;
-  return {
-    [`${prefix}_NAME`]: value.name,
-  };
-};
-
-/**
- * No-operation processor for resources that don't require environment variables.
+// Re-export everything from SstEnvironmentBuilder
+export {
+  SstEnvironmentBuilder,
+  sstResolvers,
+  ResourceType,
+  type ApiGatewayV2,
+  type Postgres,
+  type Function,
+  type Bucket,
+  type Vpc,
+  type Secret,
+  type SnsTopic,
+  type SstResource,
+  type ResourceProcessor,
+} from './SstEnvironmentBuilder';
+
+// Re-export environmentCase from EnvironmentBuilder
+export { environmentCase } from './EnvironmentBuilder';
+
+// Re-export types from EnvironmentBuilder
+export type {
+  EnvRecord,
+  EnvValue,
+  EnvironmentBuilderOptions,
+} from './EnvironmentBuilder';
+
+// Import for deprecated function
+import {
+  SstEnvironmentBuilder,
+  type SstResource,
+} from './SstEnvironmentBuilder';
+
+/**
+ * @deprecated Use `new SstEnvironmentBuilder(record).build()` instead.
  *
- * @param name - The resource name (unused)
- * @param value - The resource value (unused)
- * @returns Empty object
- */
-const noop = (name: string, value: any) => ({});
-
-/**
- * Map of resource types to their corresponding processor functions.
- * Each processor converts resource data into environment variables.
- */
-const processors: Record<ResourceType, ResourceProcessor<any>> = {
-  [ResourceType.ApiGatewayV2]: noop,
-  [ResourceType.Function]: noop,
-  [ResourceType.Vpc]: noop,
-  [ResourceType.Secret]: secret,
-  [ResourceType.Postgres]: postgres,
-  [ResourceType.Bucket]: bucket,
-
-  [ResourceType.SSTSecret]: secret,
-  [ResourceType.SSTBucket]: bucket,
-  [ResourceType.SSTFunction]: noop,
-  [ResourceType.SSTPostgres]: postgres,
-  [ResourceType.SSTApiGatewayV2]: noop,
-};
-
-/**
  * Normalizes SST resources and plain strings into environment variables.
  * Processes resources based on their type and converts names to environment case.
  *
@@ -116,106 +40,20 @@ const processors: Record<ResourceType, ResourceProcessor<any>> = {
  * @returns Normalized environment variables object
  *
  * @example
- * normalizeResourceEnv({
- *   apiUrl: 'https://api.example.com',
- *   database: { type: ResourceType.Postgres, ... }
- * })
+ * // Old usage (deprecated):
+ * normalizeResourceEnv({ database: postgresResource })
+ *
+ * // New usage:
+ * new SstEnvironmentBuilder({ database: postgresResource }).build()
  */
 export function normalizeResourceEnv(
-  record: Record<string, Resource | string>,
-): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const [k, value] of Object.entries(record)) {
-    if (typeof value === 'string') {
-      env[environmentCase(k)] = value;
-      continue;
-    }
-
-    const processor = processors[value.type];
-    if (processor) {
-      Object.assign(env, processor(k, value));
-    } else {
-      console.warn(`No processor found for resource type: `, { value });
-    }
-  }
-
-  return env;
+  record: Record<string, SstResource | string>,
+): Record<string, string | number | boolean | Record<string, unknown>> {
+  return new SstEnvironmentBuilder(record).build();
 }
 
+// Keep Resource type as deprecated alias for backwards compatibility
 /**
- * AWS API Gateway V2 resource type.
- * Represents an HTTP/WebSocket API.
- */
-export type ApiGatewayV2 = {
-  type: ResourceType.ApiGatewayV2;
-  url: string;
-};
-
-/**
- * PostgreSQL database resource type.
- * Contains all connection details needed to connect to the database.
- */
-export type Postgres = {
-  database: string;
-  host: string;
-  password: string;
-  port: number;
-  type: ResourceType.Postgres;
-  username: string;
-};
-
-/**
- * AWS Lambda Function resource type.
- */
-export type Function = {
-  name: string;
-  type: ResourceType.Function;
-};
-
-/**
- * AWS S3 Bucket resource type.
- */
-export type Bucket = {
-  name: string;
-  type: ResourceType.Bucket;
-};
-
-/**
- * AWS VPC (Virtual Private Cloud) resource type.
- */
-export type Vpc = {
-  bastion: string;
-  type: ResourceType.Vpc;
-};
-
-/**
- * Secret resource type for storing sensitive values.
- */
-export type Secret = {
-  type: ResourceType.Secret;
-  value: string;
-};
-
-/**
- * Union type of all supported SST resource types.
- */
-export type Resource =
-  | ApiGatewayV2
-  | Postgres
-  | Function
-  | Bucket
-  | Vpc
-  | Secret;
-
-/**
- * Function type for processing a specific resource type into environment variables.
- *
- * @template K - The specific resource type
- * @param name - The resource name
- * @param value - The resource value
- * @returns Object mapping environment variable names to values
+ * @deprecated Use `SstResource` instead.
  */
-export type ResourceProcessor<K extends Resource> = (
-  name: string,
-  value: K,
-) => Record<string, string | number>;
+export type Resource = SstResource;