glasswork 0.1.0 → 0.2.0

package/README.md

@@ -4,51 +4,32 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 [![Status](https://img.shields.io/badge/Status-Beta-orange.svg)](https://github.com/yourusername/glasswork)
 
-**A transparent, Lambda-optimized web framework for building OpenAPI-compliant REST APIs.**
+**A transparent, serverless-optimized web framework for building OpenAPI-compliant REST APIs.**
 
-Built on Hono, Awilix, and Prisma, Glasswork helps you create production-ready APIs with automatic OpenAPI spec generation, type-safe routing, and clean architecture.
+Built on Hono, Awilix, and Valibot, Glasswork provides automatic OpenAPI spec generation, type-safe routing, dependency injection, and clean modular architecture.
 
 ## Why Glasswork?
 
-**Build NestJS-quality APIs that run practically for free on Lambda.**
+**NestJS-style architecture with serverless-first design.**
 
-If you're building hobby projects or side APIs, you want:
+Glasswork combines the best patterns from NestJS (modules, DI, OpenAPI) with the performance characteristics needed for serverless:
 
-- **Near-zero hosting costs** - Lambda + S3 is practically free at low usage
-- **Professional architecture** - Clean separation, DI, modules (like NestJS)
-- **Automatic OpenAPI docs** - No manual Swagger decorators
-- **Fast deployment** - No containers, no servers to maintain
-- **Easy testing** - Services are framework-agnostic, no HTTP mocking needed
+- **Small & Fast** - tiny bundles (~1MB incl Prisma), no decorators, no reflection
+- **Clean Architecture** - Module system with dependency injection (Awilix)
+- **OpenAPI Built-in** - Automatic spec generation from Valibot schemas
+- **Framework-Agnostic Services** - Test business logic without HTTP mocking
+- **Transparent** - Direct access to Hono, no heavy abstractions
 
-### The Problem with NestJS on Lambda
-
-NestJS is excellent for professional projects, but on Lambda it has issues:
-
-- Large bundle size = slower cold starts
-- Decorators and reflection = harder to tree-shake
-- Heavy abstractions = less control over the HTTP layer
-- Requires containers for full features (not Lambda-friendly)
-
-### The Glasswork Solution
-
-Keep what's great about NestJS (modules, DI, OpenAPI), but:
-
-- ~1MB bundles with fast cold starts
-- No decorators, no reflection - just TypeScript
-- Direct access to Hono, Awilix, Prisma (no framework lock-in)
-- Built specifically for Lambda deployment
-- Still maintain clean architecture and testability
-
-**Perfect for:** Hobby projects, MVPs, side APIs, serverless-first applications
+**Perfect for:** Lambda-first projects, MVPs, hobby APIs, or anywhere you want NestJS patterns without the bundle size.
 
 ## Features
 
 - **OpenAPI-First**: Automatic spec generation from Valibot schemas - write code, get docs
 - **Type-Safe Routes**: Request/response validation with full TypeScript inference
 - **Module System**: Organize your API into logical, testable modules
-- **Dependency Injection**: Powered by Awilix with Lambda-compatible PROXY mode
+- **Dependency Injection**: Powered by Awilix with serverless-compatible PROXY mode
 - **Framework-Agnostic Services**: Test business logic without any HTTP mocking
-- **Lambda-Optimized**: ~1MB bundles, fast cold starts, production-ready
+- **Production-Ready**: Small bundles, fast cold starts, works anywhere Node.js runs
 
 ## Installation
 
@@ -152,26 +133,24 @@ export default app; // Ready for Lambda or local server
 
 ## When to Use Glasswork
 
-**Choose Glasswork if you:**
+**Choose Glasswork when you want:**
 
-- Want to deploy on Lambda (hobby projects, low-cost hosting)
-- Like NestJS patterns but need smaller bundles
-- Value clean architecture and testability
-- Want automatic OpenAPI without decorators
-- Prefer transparency over heavy abstractions
+- NestJS-style architecture with smaller bundles
+- Automatic OpenAPI generation without decorators
+- Serverless-first design (Lambda, Cloudflare Workers, etc.)
+- Clean, testable code with dependency injection
 
-**Consider alternatives if you:**
+**Consider alternatives:**
 
-- Need GraphQL (use Apollo Server, Pothos)
-- Deploy to containers anyway (use NestJS, it's excellent)
-- Want full-stack with frontend (use Next.js, Remix)
-- Need minimal setup with zero opinions (use Hono directly)
+- **GraphQL?** Use Apollo Server or Pothos
+- **Container deployment?** NestJS is excellent for this
+- **Full-stack app?** Use Next.js or Remix
+- **Minimal framework?** Use Hono directly
 
 ## Requirements
 
 - Node.js 18+
 - TypeScript 5+
-- (Optional) AWS Lambda for serverless deployment
 
 ## Contributing
 

package/dist/config/config-service.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Core configuration service implementation.
+ *
+ * @module config/config-service
+ */
+import { type BaseIssue, type BaseSchema } from 'valibot';
+import type { Config, ConfigOptions } from './types.js';
+/**
+ * Exception thrown when config validation fails.
+ */
+export declare class ConfigValidationException extends Error {
+    readonly issues: unknown[];
+    constructor(message: string, issues: unknown[]);
+}
+/**
+ * Creates a configuration service that loads from multiple providers
+ * and validates with Valibot.
+ *
+ * Providers are executed in order and their results are merged together,
+ * with later providers taking precedence. The merged config is then
+ * validated against the provided Valibot schema.
+ *
+ * @template TSchema - Valibot schema for validation
+ * @param options - Configuration options
+ * @returns Promise resolving to validated Config
+ *
+ * @throws {ConfigValidationException} If validation fails
+ *
+ * @example
+ * ```typescript
+ * import { object, string, number } from 'valibot';
+ *
+ * const schema = object({
+ *   nodeEnv: string(),
+ *   port: number(),
+ *   databaseUrl: string(),
+ * });
+ *
+ * const config = await createConfig({
+ *   schema,
+ *   providers: [
+ *     dotenvProvider({ path: '.env' }),
+ *     envProvider(), // env vars override .env
+ *   ],
+ * });
+ *
+ * // Fully typed access
+ * const port = config.get('port'); // number
+ * const dbUrl = config.get('databaseUrl'); // string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With key transformation (SNAKE_CASE -> camelCase)
+ * const config = await createConfig({
+ *   schema,
+ *   providers: [envProvider()],
+ *   transformKey: (key) =>
+ *     key.toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register as DI service
+ * export const AppModule = defineModule({
+ *   name: 'app',
+ *   providers: [
+ *     {
+ *       name: 'config',
+ *       useFactory: async () =>
+ *         await createConfig({
+ *           schema: appConfigSchema,
+ *           providers: [dotenvProvider(), envProvider()],
+ *         }),
+ *       lifetime: 'SINGLETON',
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export declare function createConfig<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(options: ConfigOptions<TSchema>): Promise<Config<TSchema>>;
+/**
+ * Synchronously validates config that's already loaded.
+ * Useful when you have config in memory and just need validation.
+ *
+ * @template TSchema - Valibot schema for validation
+ * @param schema - Valibot schema
+ * @param data - Raw config data to validate
+ * @returns Validated Config
+ *
+ * @throws {ConfigValidationException} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const rawConfig = { nodeEnv: 'production', port: 3000 };
+ * const config = validateConfig(schema, rawConfig);
+ * ```
+ */
+export declare function validateConfig<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, data: Record<string, unknown>): Config<TSchema>;
+//# sourceMappingURL=config-service.d.ts.map

package/dist/config/config-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-service.d.ts","sourceRoot":"","sources":["../../src/config/config-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAsC,MAAM,SAAS,CAAC;AAG9F,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAExD;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;aAGhC,MAAM,EAAE,OAAO,EAAE;gBADjC,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,OAAO,EAAE;CAKpC;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAsB,YAAY,CAChC,OAAO,SAAS,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,EAChE,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAyC3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,EAC7F,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,OAAO,CAAC,CAUjB"}

package/dist/config/config-service.js

@@ -0,0 +1,164 @@
+/**
+ * Core configuration service implementation.
+ *
+ * @module config/config-service
+ */
+import { parse, safeParse } from 'valibot';
+import { deepMerge } from '../utils/deep-merge.js';
+import { envProvider } from './providers.js';
+/**
+ * Exception thrown when config validation fails.
+ */
+export class ConfigValidationException extends Error {
+    issues;
+    constructor(message, issues) {
+        super(message);
+        this.issues = issues;
+        this.name = 'ConfigValidationException';
+    }
+}
+/**
+ * Implementation of the Config interface.
+ */
+class ConfigImpl {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    get(key) {
+        return this.data[key];
+    }
+    getOrDefault(key, defaultValue) {
+        const value = this.data[key];
+        return value !== undefined ? value : defaultValue;
+    }
+}
+/**
+ * Creates a configuration service that loads from multiple providers
+ * and validates with Valibot.
+ *
+ * Providers are executed in order and their results are merged together,
+ * with later providers taking precedence. The merged config is then
+ * validated against the provided Valibot schema.
+ *
+ * @template TSchema - Valibot schema for validation
+ * @param options - Configuration options
+ * @returns Promise resolving to validated Config
+ *
+ * @throws {ConfigValidationException} If validation fails
+ *
+ * @example
+ * ```typescript
+ * import { object, string, number } from 'valibot';
+ *
+ * const schema = object({
+ *   nodeEnv: string(),
+ *   port: number(),
+ *   databaseUrl: string(),
+ * });
+ *
+ * const config = await createConfig({
+ *   schema,
+ *   providers: [
+ *     dotenvProvider({ path: '.env' }),
+ *     envProvider(), // env vars override .env
+ *   ],
+ * });
+ *
+ * // Fully typed access
+ * const port = config.get('port'); // number
+ * const dbUrl = config.get('databaseUrl'); // string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With key transformation (SNAKE_CASE -> camelCase)
+ * const config = await createConfig({
+ *   schema,
+ *   providers: [envProvider()],
+ *   transformKey: (key) =>
+ *     key.toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register as DI service
+ * export const AppModule = defineModule({
+ *   name: 'app',
+ *   providers: [
+ *     {
+ *       name: 'config',
+ *       useFactory: async () =>
+ *         await createConfig({
+ *           schema: appConfigSchema,
+ *           providers: [dotenvProvider(), envProvider()],
+ *         }),
+ *       lifetime: 'SINGLETON',
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export async function createConfig(options) {
+    const { schema, providers = [envProvider()], transformKey, allowUnknownKeys = true } = options;
+    // Load config from all providers
+    let rawConfig = {};
+    for (const provider of providers) {
+        const providerConfig = await provider();
+        rawConfig = deepMerge(rawConfig, providerConfig);
+    }
+    // Transform keys if requested
+    if (transformKey) {
+        const transformed = {};
+        for (const [key, value] of Object.entries(rawConfig)) {
+            transformed[transformKey(key)] = value;
+        }
+        rawConfig = transformed;
+    }
+    // Filter unknown keys if requested
+    if (!allowUnknownKeys && typeof schema === 'object' && 'entries' in schema) {
+        const entries = schema.entries;
+        const schemaKeys = new Set(Object.keys(entries));
+        const filtered = {};
+        for (const [key, value] of Object.entries(rawConfig)) {
+            if (schemaKeys.has(key)) {
+                filtered[key] = value;
+            }
+        }
+        rawConfig = filtered;
+    }
+    // Validate with Valibot
+    const result = safeParse(schema, rawConfig);
+    if (!result.success) {
+        throw new ConfigValidationException('Configuration validation failed', result.issues);
+    }
+    return new ConfigImpl(result.output);
+}
+/**
+ * Synchronously validates config that's already loaded.
+ * Useful when you have config in memory and just need validation.
+ *
+ * @template TSchema - Valibot schema for validation
+ * @param schema - Valibot schema
+ * @param data - Raw config data to validate
+ * @returns Validated Config
+ *
+ * @throws {ConfigValidationException} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const rawConfig = { nodeEnv: 'production', port: 3000 };
+ * const config = validateConfig(schema, rawConfig);
+ * ```
+ */
+export function validateConfig(schema, data) {
+    try {
+        const validated = parse(schema, data);
+        return new ConfigImpl(validated);
+    }
+    catch (error) {
+        throw new ConfigValidationException('Configuration validation failed', error.issues || []);
+    }
+}
+//# sourceMappingURL=config-service.js.map

package/dist/config/config-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-service.js","sourceRoot":"","sources":["../../src/config/config-service.ts"],"names":[],"mappings":"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"}

package/dist/config/helpers.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Helper functions for working with configuration.
+ *
+ * @module config/helpers
+ */
+/**
+ * Transforms a SNAKE_CASE or kebab-case string to camelCase.
+ *
+ * Useful as a transformKey function when environment variables
+ * use UPPER_SNAKE_CASE but your schema uses camelCase.
+ *
+ * @param key - The key to transform
+ * @returns Transformed key in camelCase
+ *
+ * @example
+ * ```typescript
+ * toCamelCase('DATABASE_URL') // 'databaseUrl'
+ * toCamelCase('api-key') // 'apiKey'
+ * toCamelCase('NODE_ENV') // 'nodeEnv'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use with createConfig
+ * const config = await createConfig({
+ *   schema,
+ *   transformKey: toCamelCase,
+ *   providers: [envProvider()],
+ * });
+ * ```
+ */
+export declare function toCamelCase(key: string): string;
+/**
+ * Transforms a string to UPPER_SNAKE_CASE.
+ *
+ * Useful for reverse transformation or normalization.
+ *
+ * @param key - The key to transform
+ * @returns Transformed key in UPPER_SNAKE_CASE
+ *
+ * @example
+ * ```typescript
+ * toSnakeCase('databaseUrl') // 'DATABASE_URL'
+ * toSnakeCase('apiKey') // 'API_KEY'
+ * ```
+ */
+export declare function toSnakeCase(key: string): string;
+/**
+ * Parses a string value to boolean.
+ *
+ * Useful for environment variables that come as strings.
+ * Recognizes: 'true', '1', 'yes', 'on' as true (case-insensitive).
+ *
+ * @param value - String value to parse
+ * @returns Boolean value
+ *
+ * @example
+ * ```typescript
+ * parseBoolean('true') // true
+ * parseBoolean('1') // true
+ * parseBoolean('yes') // true
+ * parseBoolean('on') // true
+ * parseBoolean('false') // false
+ * parseBoolean('0') // false
+ * ```
+ */
+export declare function parseBoolean(value: string): boolean;
+/**
+ * Parses a comma-separated string into an array.
+ *
+ * Useful for environment variables that contain lists.
+ *
+ * @param value - String value to parse
+ * @param trim - Whether to trim whitespace from items
+ * @returns Array of strings
+ *
+ * @example
+ * ```typescript
+ * parseArray('a,b,c') // ['a', 'b', 'c']
+ * parseArray('a, b, c', true) // ['a', 'b', 'c']
+ * parseArray('') // []
+ * ```
+ */
+export declare function parseArray(value: string, trim?: boolean): string[];
+/**
+ * Parses a JSON string safely.
+ *
+ * Useful for environment variables that contain JSON objects.
+ * Returns undefined if parsing fails instead of throwing.
+ *
+ * @param value - JSON string to parse
+ * @returns Parsed object or undefined
+ *
+ * @example
+ * ```typescript
+ * parseJson('{"key": "value"}') // { key: 'value' }
+ * parseJson('invalid') // undefined
+ * ```
+ */
+export declare function parseJson(value: string): unknown;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/config/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/config/helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,UAAO,GAAG,MAAM,EAAE,CAG/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMhD"}

package/dist/config/helpers.js

@@ -0,0 +1,122 @@
+/**
+ * Helper functions for working with configuration.
+ *
+ * @module config/helpers
+ */
+/**
+ * Transforms a SNAKE_CASE or kebab-case string to camelCase.
+ *
+ * Useful as a transformKey function when environment variables
+ * use UPPER_SNAKE_CASE but your schema uses camelCase.
+ *
+ * @param key - The key to transform
+ * @returns Transformed key in camelCase
+ *
+ * @example
+ * ```typescript
+ * toCamelCase('DATABASE_URL') // 'databaseUrl'
+ * toCamelCase('api-key') // 'apiKey'
+ * toCamelCase('NODE_ENV') // 'nodeEnv'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use with createConfig
+ * const config = await createConfig({
+ *   schema,
+ *   transformKey: toCamelCase,
+ *   providers: [envProvider()],
+ * });
+ * ```
+ */
+export function toCamelCase(key) {
+    return key.toLowerCase().replace(/[_-]([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+/**
+ * Transforms a string to UPPER_SNAKE_CASE.
+ *
+ * Useful for reverse transformation or normalization.
+ *
+ * @param key - The key to transform
+ * @returns Transformed key in UPPER_SNAKE_CASE
+ *
+ * @example
+ * ```typescript
+ * toSnakeCase('databaseUrl') // 'DATABASE_URL'
+ * toSnakeCase('apiKey') // 'API_KEY'
+ * ```
+ */
+export function toSnakeCase(key) {
+    return key
+        .replace(/([A-Z])/g, '_$1')
+        .replace(/^_/, '')
+        .toUpperCase();
+}
+/**
+ * Parses a string value to boolean.
+ *
+ * Useful for environment variables that come as strings.
+ * Recognizes: 'true', '1', 'yes', 'on' as true (case-insensitive).
+ *
+ * @param value - String value to parse
+ * @returns Boolean value
+ *
+ * @example
+ * ```typescript
+ * parseBoolean('true') // true
+ * parseBoolean('1') // true
+ * parseBoolean('yes') // true
+ * parseBoolean('on') // true
+ * parseBoolean('false') // false
+ * parseBoolean('0') // false
+ * ```
+ */
+export function parseBoolean(value) {
+    const normalized = value.toLowerCase().trim();
+    return ['true', '1', 'yes', 'on'].includes(normalized);
+}
+/**
+ * Parses a comma-separated string into an array.
+ *
+ * Useful for environment variables that contain lists.
+ *
+ * @param value - String value to parse
+ * @param trim - Whether to trim whitespace from items
+ * @returns Array of strings
+ *
+ * @example
+ * ```typescript
+ * parseArray('a,b,c') // ['a', 'b', 'c']
+ * parseArray('a, b, c', true) // ['a', 'b', 'c']
+ * parseArray('') // []
+ * ```
+ */
+export function parseArray(value, trim = true) {
+    if (!value)
+        return [];
+    return value.split(',').map((item) => (trim ? item.trim() : item));
+}
+/**
+ * Parses a JSON string safely.
+ *
+ * Useful for environment variables that contain JSON objects.
+ * Returns undefined if parsing fails instead of throwing.
+ *
+ * @param value - JSON string to parse
+ * @returns Parsed object or undefined
+ *
+ * @example
+ * ```typescript
+ * parseJson('{"key": "value"}') // { key: 'value' }
+ * parseJson('invalid') // undefined
+ * ```
+ */
+export function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=helpers.js.map

package/dist/config/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/config/helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;AACvF,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,OAAO,GAAG;SACP,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC;SAC1B,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;SACjB,WAAW,EAAE,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IAC9C,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,IAAI,GAAG,IAAI;IACnD,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/config/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Configuration management for Glasswork applications.
+ *
+ * Provides a flexible, type-safe way to load and validate configuration
+ * from multiple sources (environment variables, .env files, AWS SSM, etc.)
+ * using Valibot schemas.
+ *
+ * @module config
+ *
+ * @example
+ * ```typescript
+ * import { object, string, number } from 'valibot';
+ * import { createConfig, dotenvProvider, envProvider } from 'glasswork';
+ *
+ * // Define schema
+ * const configSchema = object({
+ *   nodeEnv: string(),
+ *   port: number(),
+ *   databaseUrl: string(),
+ * });
+ *
+ * // Create config with multiple providers
+ * const config = await createConfig({
+ *   schema: configSchema,
+ *   providers: [
+ *     dotenvProvider({ path: '.env' }),
+ *     envProvider(), // Env vars override .env
+ *   ],
+ * });
+ *
+ * // Type-safe access
+ * const port = config.get('port'); // number
+ * ```
+ */
+export { ConfigValidationException, createConfig, validateConfig } from './config-service.js';
+export { parseArray, parseBoolean, parseJson, toCamelCase, toSnakeCase, } from './helpers.js';
+export { type DotenvProviderOptions, dotenvProvider, type EnvProviderOptions, envProvider, objectProvider, type SsmProviderOptions, ssmProvider, } from './providers.js';
+export type { Config, ConfigOptions, ConfigProvider } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAAE,yBAAyB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE9F,OAAO,EACL,UAAU,EACV,YAAY,EACZ,SAAS,EACT,WAAW,EACX,WAAW,GACZ,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,KAAK,qBAAqB,EAC1B,cAAc,EACd,KAAK,kBAAkB,EACvB,WAAW,EACX,cAAc,EACd,KAAK,kBAAkB,EACvB,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}