@digitaldefiance/ecies-lib 4.10.7 → 4.10.8

package/README.md

@@ -8,7 +8,7 @@ Production-ready, browser-compatible ECIES (Elliptic Curve Integrated Encryption
 
 Part of [Express Suite](https://github.com/Digital-Defiance/express-suite)
 
-**Current Version: v4.10.6**
+**Current Version: v4.10.7**
 
 This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuring HKDF key derivation, AAD binding, and optimized multi-recipient encryption. It includes a pluggable ID provider system with PlatformID support, memory-efficient streaming encryption, comprehensive internationalization, and a complete cryptographic voting system with 15+ voting methods.
 
@@ -47,6 +47,7 @@ This library implements a modern, enterprise-grade ECIES protocol (v4.0) featuri
   - **PlatformID Type**: Generic type system supporting `Uint8Array | GuidV4 | ObjectId | string`
   - **Auto-Sync**: Configuration automatically adapts all cryptographic constants to the selected ID provider
   - **Member System**: User abstraction with cryptographic operations, fully integrated with the configured ID provider
+  - **Strong Typing**: New typed configuration system provides compile-time type safety for ID operations
 - **Key Management**:
   - **BIP39**: Mnemonic phrase generation (12-24 words).
   - **HD Wallets**: BIP32/BIP44 hierarchical deterministic derivation.
@@ -201,7 +202,8 @@ import {
   ECIESService, 
   getEciesI18nEngine, 
   createRuntimeConfiguration, 
-  ObjectIdProvider 
+  ObjectIdProvider,
+  getEnhancedIdProvider
 } from '@digitaldefiance/ecies-lib';
 
 // 1. Initialize i18n (required once)
@@ -227,6 +229,12 @@ const encrypted = await ecies.encryptSimpleOrSingle(false, publicKey, message);
 const decrypted = await ecies.decryptSimpleOrSingleWithHeader(false, privateKey, encrypted);
 
 console.log(new TextDecoder().decode(decrypted)); // "Hello, Secure World!"
+
+// 6. Strong Typing for ID Operations (NEW!)
+const idProvider = getEnhancedIdProvider<ObjectId>();
+const objectId = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+const serialized = idProvider.serializeTyped(objectId); // Accepts ObjectId directly
+const deserialized = idProvider.deserializeTyped(serialized); // Returns ObjectId
 ```
 
 ## Cryptographic Voting System
@@ -394,7 +402,55 @@ VotingSecurityValidator.validate(VotingMethod.Quadratic); // Throws error
 VotingSecurityValidator.validate(VotingMethod.Quadratic, { allowInsecure: true });
 ```
 
-### 2. Using Custom ID Providers (e.g., GUID)
+### 2. Strong Typing for ID Providers (NEW!)
+
+The library now provides strongly-typed alternatives to the weak typing pattern `Constants.idProvider.generate()`:
+
+```typescript
+import { 
+  getRuntimeConfiguration,
+  getEnhancedIdProvider,
+  getTypedIdProvider,
+  createObjectIdConfiguration
+} from '@digitaldefiance/ecies-lib';
+import { ObjectId } from 'bson';
+
+// BEFORE: Weak typing (still works for compatibility)
+const Constants = getRuntimeConfiguration();
+const rawBytes = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+const nativeId = Constants.idProvider.fromBytes(rawBytes); // Returns unknown, requires casting
+
+// AFTER: Strong typing - Option 1 (Enhanced Provider - Recommended)
+const enhancedProvider = getEnhancedIdProvider<ObjectId>();
+
+// Original methods still work exactly the same
+const rawBytes2 = enhancedProvider.generate(); // Uint8Array (same as before)
+const isValid = enhancedProvider.validate(rawBytes2); // boolean (same as before)
+
+// Plus new strongly-typed methods
+const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+const validTyped = enhancedProvider.validateTyped(objectId); // boolean, accepts ObjectId
+const serialized = enhancedProvider.serializeTyped(objectId); // string, accepts ObjectId
+const deserialized = enhancedProvider.deserializeTyped(serialized); // ObjectId
+
+// AFTER: Strong typing - Option 2 (Simple Typed Provider)
+const typedProvider = getTypedIdProvider<ObjectId>();
+const bytes = typedProvider.generate();
+const typedId = typedProvider.fromBytes(bytes); // Returns ObjectId, not unknown!
+
+// AFTER: Strong typing - Option 3 (Configuration Wrapper)
+const config = createObjectIdConfiguration();
+const configId = config.generateId(); // ObjectId directly!
+const configValid = config.validateId(configId); // boolean, accepts ObjectId
+```
+
+**Benefits:**
+- ✅ **Full IntelliSense** - Autocomplete for native ID methods (`objectId.toHexString()`)
+- ✅ **Compile-time checking** - Prevents type mismatches at build time
+- ✅ **Zero breaking changes** - All existing code continues to work
+- ✅ **Multiple migration paths** - Choose the approach that fits your use case
+
+### 3. Using Custom ID Providers (e.g., GUID)
 
 ```typescript
 import { 
@@ -413,7 +469,7 @@ const ecies = new ECIESService(config);
 const id = config.idProvider.generate(); // Returns 16-byte Uint8Array
 ```
 
-### 3. Streaming Encryption (Large Files)
+### 4. Streaming Encryption (Large Files)
 
 Encrypt gigabytes of data with minimal memory footprint (<10MB).
 
@@ -437,7 +493,7 @@ async function processFile(fileStream: ReadableStream, publicKey: Uint8Array) {
 }
 ```
 
-### 4. Member System
+### 5. Member System
 
 The `Member` class provides a high-level user abstraction that integrates keys, IDs, and encryption.
 
@@ -973,6 +1029,27 @@ class MemberService {
   - `get(key)`: Retrieve a configuration.
 - **`createRuntimeConfiguration(overrides)`**: Creates a validated configuration object with your overrides.
 
+### Strong Typing System (NEW!)
+
+- **`getEnhancedIdProvider<T>(key?)`**: Get a strongly-typed ID provider with enhanced convenience methods
+  - Drop-in replacement for `Constants.idProvider` with both original and typed methods
+  - `generateTyped()`: Generate ID with native type (e.g., `ObjectId`)
+  - `validateTyped(id)`: Validate ID with native type
+  - `serializeTyped(id)`: Serialize ID with native type
+  - `deserializeTyped(str)`: Deserialize to native type
+- **`getTypedIdProvider<T>(key?)`**: Get a simple strongly-typed ID provider
+  - Minimal API surface with type-safe conversions
+  - `fromBytes(bytes)`: Returns native type instead of `unknown`
+- **`createObjectIdConfiguration(overrides?)`**: Create ObjectId-typed configuration
+- **`createGuidV4Configuration(overrides?)`**: Create GuidV4-typed configuration
+- **`createUint8ArrayConfiguration(overrides?)`**: Create Uint8Array-typed configuration
+- **`createUuidConfiguration(overrides?)`**: Create UUID string-typed configuration
+- **`TypedConfiguration<T>`**: Configuration wrapper with strongly-typed ID operations
+  - `generateId()`: Generate ID with native type
+  - `validateId(id)`: Validate ID with native type
+  - `serializeId(id)`: Serialize ID with native type
+  - `deserializeId(str)`: Deserialize to native type
+
 ### Secure Primitives
 
 - **`SecureString` / `SecureBuffer`**:
@@ -1181,6 +1258,59 @@ The library maintains **100% test coverage** with over 1,200 tests, including:
 
 ## ChangeLog
 
+### v4.10.7 - Strong Typing for ID Providers
+
+**Major Features:**
+- **Strong Typing System**: Added comprehensive strong typing solution for ID provider operations
+  - `getEnhancedIdProvider<T>()`: Drop-in replacement for `Constants.idProvider` with typed methods
+  - `getTypedIdProvider<T>()`: Simple typed provider for minimal API surface
+  - `createObjectIdConfiguration()`: ObjectId-typed configuration factory
+  - `TypedConfiguration<T>`: Configuration wrapper with strongly-typed ID operations
+- **Enhanced Developer Experience**: 
+  - Full IntelliSense support for native ID types (`ObjectId`, `GuidV4`, `string`, etc.)
+  - Compile-time type checking prevents runtime type errors
+  - Multiple migration paths to choose from based on use case
+- **Zero Breaking Changes**: All existing code continues to work unchanged
+  - Original `Constants.idProvider` pattern still supported
+  - Enhanced providers include all original methods plus typed alternatives
+  - Backward compatibility maintained for all existing APIs
+
+**New APIs:**
+- `getEnhancedIdProvider<T>(key?)`: Enhanced provider with typed convenience methods
+- `getTypedIdProvider<T>(key?)`: Simple typed provider
+- `createObjectIdConfiguration(overrides?)`: ObjectId-typed configuration
+- `createGuidV4Configuration(overrides?)`: GuidV4-typed configuration  
+- `createUint8ArrayConfiguration(overrides?)`: Uint8Array-typed configuration
+- `createUuidConfiguration(overrides?)`: UUID string-typed configuration
+- `TypedIdProviderWrapper<T>`: Enhanced wrapper with typed methods
+
+**Migration Examples:**
+```typescript
+// BEFORE: Weak typing
+const Constants = getRuntimeConfiguration();
+const id = Constants.idProvider.generate(); // Uint8Array, no strong typing
+
+// AFTER: Strong typing (multiple options)
+const enhancedProvider = getEnhancedIdProvider<ObjectId>();
+const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+
+const typedProvider = getTypedIdProvider<ObjectId>();
+const typedId = typedProvider.fromBytes(bytes); // ObjectId, not unknown!
+
+const config = createObjectIdConfiguration();
+const configId = config.generateId(); // ObjectId directly!
+```
+
+**Documentation:**
+- Added comprehensive migration guide (`src/migration-guide.md`)
+- Updated README with strong typing examples
+- Added usage examples and real-world migration patterns
+
+**Testing:**
+- 14 new tests covering all strong typing scenarios
+- Property-based tests for type safety validation
+- Migration pattern tests for backward compatibility
+
 ### v4.10.6 - Voting System & PlatformID Integration
 
 **Major Features:**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/ecies-lib",
-  "version": "4.10.7",
+  "version": "4.10.8",
   "description": "Digital Defiance ECIES Library",
   "homepage": "https://github.com/Digital-Defiance/ecies-lib",
   "repository": {

package/src/examples/typed-configuration-usage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Examples showing how to use the typed configuration system for strong ID provider typing.
+ * This demonstrates the solution to the original problem where Constants.idProvider.generate()
+ * had no strong typing.
+ */
+declare function beforeExample(): void;
+declare function afterExample(): void;
+declare function realWorldUsage(): void;
+declare function serviceIntegration(): void;
+declare function typeSafetyDemo(): void;
+export { beforeExample, afterExample, realWorldUsage, serviceIntegration, typeSafetyDemo, };
+//# sourceMappingURL=typed-configuration-usage.d.ts.map

package/src/examples/typed-configuration-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration-usage.d.ts","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/examples/typed-configuration-usage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiBH,iBAAS,aAAa,SAKrB;AAMD,iBAAS,YAAY,SAsBpB;AAMD,iBAAS,cAAc,SAsBtB;AAMD,iBAAS,kBAAkB,SAU1B;AAMD,iBAAS,cAAc,SAgBtB;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,CAAC"}

package/src/examples/typed-configuration-usage.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Examples showing how to use the typed configuration system for strong ID provider typing.
+ * This demonstrates the solution to the original problem where Constants.idProvider.generate()
+ * had no strong typing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeExample = beforeExample;
+exports.afterExample = afterExample;
+exports.realWorldUsage = realWorldUsage;
+exports.serviceIntegration = serviceIntegration;
+exports.typeSafetyDemo = typeSafetyDemo;
+const constants_1 = require("../constants");
+const guidv4_provider_1 = require("../lib/id-providers/guidv4-provider");
+const typed_configuration_1 = require("../typed-configuration");
+// ============================================================================
+// BEFORE: Weak typing with getRuntimeConfiguration()
+// ============================================================================
+function beforeExample() {
+    // This was the original problem - no strong typing
+    const Constants = (0, constants_1.getRuntimeConfiguration)();
+    const id = Constants.idProvider.generate(); // Returns Uint8Array, loses type info
+    const _nativeId = Constants.idProvider.fromBytes(id); // Returns unknown, no type safety
+}
+// ============================================================================
+// AFTER: Strong typing solutions
+// ============================================================================
+function afterExample() {
+    // Solution 1: Direct replacement for Constants.idProvider
+    const enhancedProvider = (0, typed_configuration_1.getEnhancedIdProvider)();
+    // Original methods still work exactly the same
+    const rawBytes = enhancedProvider.generate(); // Uint8Array (same as before)
+    const _isValid = enhancedProvider.validate(rawBytes); // boolean (same as before)
+    // But now you also have strongly-typed methods
+    const objectId = enhancedProvider.generateTyped(); // ObjectId - strongly typed!
+    const _validTyped = enhancedProvider.validateTyped(objectId); // boolean, accepts ObjectId
+    const serialized = enhancedProvider.serializeTyped(objectId); // string, accepts ObjectId
+    const _deserialized = enhancedProvider.deserializeTyped(serialized); // ObjectId
+    // Solution 2: Simple typed provider
+    const typedProvider = (0, typed_configuration_1.getTypedIdProvider)();
+    const bytes = typedProvider.generate();
+    const _typedId = typedProvider.fromBytes(bytes); // Returns ObjectId, not unknown!
+    // Solution 3: Configuration approach (for more complex scenarios)
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    const _configId = config.generateId(); // Returns ObjectId - strongly typed!
+}
+// ============================================================================
+// Real-world usage patterns
+// ============================================================================
+function realWorldUsage() {
+    // Pattern 1: Service initialization with strong typing
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    // Now you can use config.idProvider with full type safety
+    const newId = config.generateId(); // ObjectId
+    const _isValid = config.validateId(newId); // boolean
+    const _idString = config.serializeId(newId); // string
+    // Pattern 2: Custom provider with type inference
+    const customProvider = new guidv4_provider_1.GuidV4Provider();
+    const typedConfig = (0, typed_configuration_1.createTypedConfiguration)({
+        idProvider: customProvider,
+        // Other overrides...
+        BcryptRounds: 12,
+    });
+    const _guidId = typedConfig.generateId(); // GuidV4 - automatically inferred!
+    // Pattern 3: Backward compatibility - access underlying constants
+    const _underlyingConstants = typedConfig.constants;
+    // This still works for existing code that expects IConstants
+}
+// ============================================================================
+// Integration with ECIESService
+// ============================================================================
+function serviceIntegration() {
+    // The ECIESService can now use TypedConfiguration for better typing
+    const config = (0, typed_configuration_1.createObjectIdConfiguration)();
+    // Pass the underlying constants to existing services
+    // const service = new ECIESService<ObjectId>(config.constants);
+    // Or use the typed config directly for ID operations
+    const memberId = config.generateId(); // ObjectId
+    const _memberIdString = config.serializeId(memberId); // string
+}
+// ============================================================================
+// Type safety demonstrations
+// ============================================================================
+function typeSafetyDemo() {
+    const objectIdConfig = (0, typed_configuration_1.createObjectIdConfiguration)();
+    const guidConfig = (0, typed_configuration_1.createGuidV4Configuration)({
+        idProvider: new guidv4_provider_1.GuidV4Provider(),
+    });
+    const objectId = objectIdConfig.generateId(); // ObjectId
+    const guid = guidConfig.generateId(); // GuidV4
+    // These operations are now type-safe:
+    objectIdConfig.serializeId(objectId); // ✅ Accepts ObjectId
+    guidConfig.serializeId(guid); // ✅ Accepts GuidV4
+    // These would be compile-time errors:
+    // objectIdConfig.serializeId(guid); // ❌ Type error: GuidV4 not assignable to ObjectId
+    // guidConfig.serializeId(objectId); // ❌ Type error: ObjectId not assignable to GuidV4
+}
+//# sourceMappingURL=typed-configuration-usage.js.map

package/src/examples/typed-configuration-usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration-usage.js","sourceRoot":"","sources":["../../../../../packages/digitaldefiance-ecies-lib/src/examples/typed-configuration-usage.ts"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -15,6 +15,7 @@ export * from './lib/index';
 export { EciesComponentId, EciesI18nEngineKey, getEciesI18nEngine, getEciesTranslation, resetEciesI18nEngine, safeEciesTranslation, } from './i18n-setup';
 export { encryptionTypeEnumToType, encryptionTypeToString, ensureEciesEncryptionTypeEnum, validateEciesEncryptionTypeEnum, } from './utils/encryption-type-utils';
 export * from './constants';
+export * from './typed-configuration';
 export * from './email-string';
 export * from './enumerations';
 export * from './errors';

package/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,uBAAuB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAG5B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,+BAA+B,CAAC;AASvC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,YAAY,EACV,UAAU,EACV,SAAS,EACT,OAAO,IAAI,eAAe,GAC3B,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,uBAAuB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAG5B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,+BAA+B,CAAC;AASvC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,YAAY,EACV,UAAU,EACV,SAAS,EACT,OAAO,IAAI,eAAe,GAC3B,MAAM,iBAAiB,CAAC"}

package/src/index.js

@@ -40,6 +40,7 @@ Object.defineProperty(exports, "validateEciesEncryptionTypeEnum", { enumerable:
 // Note: Existing services will be re-exported once migrated to v2
 // For now, import from main index.ts for backward compatibility
 tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./typed-configuration"), exports);
 tslib_1.__exportStar(require("./email-string"), exports);
 tslib_1.__exportStar(require("./enumerations"), exports);
 tslib_1.__exportStar(require("./errors"), exports);

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;AAEH,mEAAmE;AACnE,wEAAwE;AACxE,iCAA+B;AAE/B,kBAAkB;AAClB,2DAAiC;AACjC,uDAA6B;AAC7B,sDAA4B;AAE5B,UAAU;AACV,2CAOsB;AANpB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,gHAAA,kBAAkB,OAAA;AAClB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,kHAAA,oBAAoB,OAAA;AAGtB,mFAAmF;AACnF,mEAAmE;AACnE,uEAKuC;AAJrC,iIAAA,wBAAwB,OAAA;AACxB,+HAAA,sBAAsB,OAAA;AACtB,sIAAA,6BAA6B,OAAA;AAC7B,wIAAA,+BAA+B,OAAA;AAGjC,2DAA2D;AAC3D,oEAAoE;AACpE,8DAA8D;AAE9D,kEAAkE;AAClE,gEAAgE;AAEhE,sDAA4B;AAC5B,yDAA+B;AAC/B,yDAA+B;AAC/B,mDAAyB;AACzB,uDAA6B;AAC7B,uEAA6C;AAC7C,kEAAyE;AAAhE,4HAAA,wBAAwB,OAAA;AAEjC,qEAA2C;AAC3C,qEAA2C;AAC3C,uEAA6C;AAC7C,6DAAmC;AACnC,4DAAkC;AAClC,mDAAyB;AACzB,4DAAkC;AAClC,yDAA+B;AAC/B,0DAAgC;AAChC,0DAAgC;AAChC,qDAA2B;AAC3B,kDAAwB;AACxB,kDAAwB;AAExB,qEAAqE;AACrE,uDAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;AAEH,mEAAmE;AACnE,wEAAwE;AACxE,iCAA+B;AAE/B,kBAAkB;AAClB,2DAAiC;AACjC,uDAA6B;AAC7B,sDAA4B;AAE5B,UAAU;AACV,2CAOsB;AANpB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,gHAAA,kBAAkB,OAAA;AAClB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,kHAAA,oBAAoB,OAAA;AAGtB,mFAAmF;AACnF,mEAAmE;AACnE,uEAKuC;AAJrC,iIAAA,wBAAwB,OAAA;AACxB,+HAAA,sBAAsB,OAAA;AACtB,sIAAA,6BAA6B,OAAA;AAC7B,wIAAA,+BAA+B,OAAA;AAGjC,2DAA2D;AAC3D,oEAAoE;AACpE,8DAA8D;AAE9D,kEAAkE;AAClE,gEAAgE;AAEhE,sDAA4B;AAC5B,gEAAsC;AACtC,yDAA+B;AAC/B,yDAA+B;AAC/B,mDAAyB;AACzB,uDAA6B;AAC7B,uEAA6C;AAC7C,kEAAyE;AAAhE,4HAAA,wBAAwB,OAAA;AAEjC,qEAA2C;AAC3C,qEAA2C;AAC3C,uEAA6C;AAC7C,6DAAmC;AACnC,4DAAkC;AAClC,mDAAyB;AACzB,4DAAkC;AAClC,yDAA+B;AAC/B,0DAAgC;AAChC,0DAAgC;AAChC,qDAA2B;AAC3B,kDAAwB;AACxB,kDAAwB;AAExB,qEAAqE;AACrE,uDAA6B"}

package/src/typed-configuration.d.ts

@@ -0,0 +1,162 @@
+import type { ObjectId } from 'bson';
+import { type ConfigurationKey } from './constants';
+import type { IConstants } from './interfaces/constants';
+import type { IIdProvider } from './interfaces/id-provider';
+import type { GuidV4 } from './lib/guid';
+import type { DeepPartial } from './types/deep-partial';
+/**
+ * Typed configuration wrapper that preserves ID provider type information.
+ * This provides strong typing for idProvider operations without making the entire
+ * constants system generic.
+ */
+export declare class TypedConfiguration<TID> {
+    private readonly _constants;
+    private readonly _idProvider;
+    constructor(constants: IConstants);
+    /**
+     * Get the strongly-typed ID provider.
+     * This returns IIdProvider<TID> with full type safety.
+     */
+    get idProvider(): IIdProvider<TID>;
+    /**
+     * Get the underlying constants (for compatibility with existing code).
+     */
+    get constants(): IConstants;
+    /**
+     * Generate a new ID with strong typing.
+     */
+    generateId(): TID;
+    /**
+     * Validate an ID with strong typing.
+     */
+    validateId(id: TID): boolean;
+    /**
+     * Serialize an ID to string with strong typing.
+     */
+    serializeId(id: TID): string;
+    /**
+     * Deserialize a string to ID with strong typing.
+     */
+    deserializeId(str: string): TID;
+}
+/**
+ * Configuration factory functions that infer and preserve ID provider types.
+ */
+/**
+ * Create a typed configuration with ObjectId provider.
+ * This is the default configuration with strong ObjectId typing.
+ */
+export declare function createObjectIdConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<ObjectId>;
+/**
+ * Create a typed configuration with GuidV4 provider.
+ */
+export declare function createGuidV4Configuration(overrides?: DeepPartial<IConstants>): TypedConfiguration<GuidV4>;
+/**
+ * Create a typed configuration with Uint8Array provider (generic bytes).
+ */
+export declare function createUint8ArrayConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<Uint8Array>;
+/**
+ * Create a typed configuration with UUID string provider.
+ */
+export declare function createUuidConfiguration(overrides?: DeepPartial<IConstants>): TypedConfiguration<string>;
+/**
+ * Get a strongly-typed ID provider from the default configuration.
+ * This is the direct equivalent of `getRuntimeConfiguration().idProvider` with strong typing.
+ *
+ * @example
+ * ```typescript
+ * // BEFORE: Weak typing
+ * const Constants = getRuntimeConfiguration();
+ * const id = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+ *
+ * // AFTER: Strong typing
+ * const idProvider = getTypedIdProvider<ObjectId>();
+ * const id = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+ * ```
+ */
+export declare function getTypedIdProvider<TID>(key?: ConfigurationKey): IIdProvider<TID>;
+/**
+ * Enhanced ID provider wrapper that adds strongly-typed convenience methods
+ * while preserving all original functionality.
+ */
+export declare class TypedIdProviderWrapper<TID> implements IIdProvider<TID> {
+    private readonly _provider;
+    constructor(provider: IIdProvider<TID>);
+    get byteLength(): number;
+    get name(): string;
+    generate(): Uint8Array;
+    validate(id: Uint8Array): boolean;
+    serialize(id: Uint8Array): string;
+    deserialize(str: string): Uint8Array;
+    toBytes(id: TID): Uint8Array;
+    fromBytes(bytes: Uint8Array): TID;
+    equals(a: TID, b: TID): boolean;
+    clone(id: TID): TID;
+    idToString(id: TID): string;
+    idFromString(str: string): TID;
+    /**
+     * Generate a new ID with strong typing.
+     * This is equivalent to generate() + fromBytes() but returns the native type directly.
+     */
+    generateTyped(): TID;
+    /**
+     * Validate an ID with strong typing.
+     * Accepts the native ID type and validates it.
+     */
+    validateTyped(id: TID): boolean;
+    /**
+     * Serialize an ID to string with strong typing.
+     * Accepts the native ID type directly.
+     */
+    serializeTyped(id: TID): string;
+    /**
+     * Deserialize a string to ID with strong typing.
+     * Returns the native ID type directly.
+     */
+    deserializeTyped(str: string): TID;
+}
+/**
+ * Get a strongly-typed ID provider with enhanced convenience methods.
+ * This provides the most ergonomic API for strongly-typed ID operations.
+ *
+ * @example
+ * ```typescript
+ * // Direct replacement for Constants.idProvider with strong typing
+ * const idProvider = getEnhancedIdProvider<ObjectId>();
+ *
+ * // All original methods work the same
+ * const bytes = idProvider.generate(); // Uint8Array
+ * const isValid = idProvider.validate(bytes); // boolean
+ *
+ * // Plus new strongly-typed methods
+ * const objectId = idProvider.generateTyped(); // ObjectId - strongly typed!
+ * const valid = idProvider.validateTyped(objectId); // boolean
+ * const serialized = idProvider.serializeTyped(objectId); // string
+ * const deserialized = idProvider.deserializeTyped(serialized); // ObjectId
+ * ```
+ */
+export declare function getEnhancedIdProvider<TID>(key?: ConfigurationKey): TypedIdProviderWrapper<TID>;
+/**
+ * Get a typed configuration from the registry.
+ * The type parameter must match the actual ID provider type.
+ *
+ * @example
+ * ```typescript
+ * // For ObjectId configurations
+ * const config = getTypedConfiguration<ObjectId>();
+ * const id = config.generateId(); // Returns ObjectId
+ *
+ * // For GUID configurations
+ * const guidConfig = getTypedConfiguration<GuidV4>('my-guid-config');
+ * const guid = guidConfig.generateId(); // Returns GuidV4
+ * ```
+ */
+export declare function getTypedConfiguration<TID>(key?: ConfigurationKey): TypedConfiguration<TID>;
+/**
+ * Type-safe configuration builder that infers the ID provider type.
+ * This provides the strongest typing by inferring TID from the idProvider.
+ */
+export declare function createTypedConfiguration<TProvider extends IIdProvider<unknown>>(config: DeepPartial<IConstants> & {
+    idProvider: TProvider;
+}): TypedConfiguration<TProvider extends IIdProvider<infer TID> ? TID : never>;
+//# sourceMappingURL=typed-configuration.d.ts.map

package/src/typed-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration.d.ts","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/typed-configuration.ts"],"names":[],"mappings":"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"}

package/src/typed-configuration.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedIdProviderWrapper = exports.TypedConfiguration = void 0;
+exports.createObjectIdConfiguration = createObjectIdConfiguration;
+exports.createGuidV4Configuration = createGuidV4Configuration;
+exports.createUint8ArrayConfiguration = createUint8ArrayConfiguration;
+exports.createUuidConfiguration = createUuidConfiguration;
+exports.getTypedIdProvider = getTypedIdProvider;
+exports.getEnhancedIdProvider = getEnhancedIdProvider;
+exports.getTypedConfiguration = getTypedConfiguration;
+exports.createTypedConfiguration = createTypedConfiguration;
+const constants_1 = require("./constants");
+/**
+ * Typed configuration wrapper that preserves ID provider type information.
+ * This provides strong typing for idProvider operations without making the entire
+ * constants system generic.
+ */
+class TypedConfiguration {
+    _constants;
+    _idProvider;
+    constructor(constants) {
+        this._constants = constants;
+        this._idProvider = constants.idProvider;
+    }
+    /**
+     * Get the strongly-typed ID provider.
+     * This returns IIdProvider<TID> with full type safety.
+     */
+    get idProvider() {
+        return this._idProvider;
+    }
+    /**
+     * Get the underlying constants (for compatibility with existing code).
+     */
+    get constants() {
+        return this._constants;
+    }
+    /**
+     * Generate a new ID with strong typing.
+     */
+    generateId() {
+        const bytes = this._idProvider.generate();
+        return this._idProvider.fromBytes(bytes);
+    }
+    /**
+     * Validate an ID with strong typing.
+     */
+    validateId(id) {
+        const bytes = this._idProvider.toBytes(id);
+        return this._idProvider.validate(bytes);
+    }
+    /**
+     * Serialize an ID to string with strong typing.
+     */
+    serializeId(id) {
+        return this._idProvider.idToString(id);
+    }
+    /**
+     * Deserialize a string to ID with strong typing.
+     */
+    deserializeId(str) {
+        return this._idProvider.idFromString(str);
+    }
+}
+exports.TypedConfiguration = TypedConfiguration;
+/**
+ * Configuration factory functions that infer and preserve ID provider types.
+ */
+/**
+ * Create a typed configuration with ObjectId provider.
+ * This is the default configuration with strong ObjectId typing.
+ */
+function createObjectIdConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with GuidV4 provider.
+ */
+function createGuidV4Configuration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with Uint8Array provider (generic bytes).
+ */
+function createUint8ArrayConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Create a typed configuration with UUID string provider.
+ */
+function createUuidConfiguration(overrides) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(overrides);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Get a strongly-typed ID provider from the default configuration.
+ * This is the direct equivalent of `getRuntimeConfiguration().idProvider` with strong typing.
+ *
+ * @example
+ * ```typescript
+ * // BEFORE: Weak typing
+ * const Constants = getRuntimeConfiguration();
+ * const id = Constants.idProvider.generate(); // Returns Uint8Array, no strong typing
+ *
+ * // AFTER: Strong typing
+ * const idProvider = getTypedIdProvider<ObjectId>();
+ * const id = idProvider.generateTyped(); // Returns ObjectId - strongly typed!
+ * ```
+ */
+function getTypedIdProvider(key) {
+    const constants = (0, constants_1.getRuntimeConfiguration)(key);
+    return constants.idProvider;
+}
+/**
+ * Enhanced ID provider wrapper that adds strongly-typed convenience methods
+ * while preserving all original functionality.
+ */
+class TypedIdProviderWrapper {
+    _provider;
+    constructor(provider) {
+        this._provider = provider;
+    }
+    // Delegate all original methods
+    get byteLength() {
+        return this._provider.byteLength;
+    }
+    get name() {
+        return this._provider.name;
+    }
+    generate() {
+        return this._provider.generate();
+    }
+    validate(id) {
+        return this._provider.validate(id);
+    }
+    serialize(id) {
+        return this._provider.serialize(id);
+    }
+    deserialize(str) {
+        return this._provider.deserialize(str);
+    }
+    toBytes(id) {
+        return this._provider.toBytes(id);
+    }
+    fromBytes(bytes) {
+        return this._provider.fromBytes(bytes);
+    }
+    equals(a, b) {
+        return this._provider.equals(a, b);
+    }
+    clone(id) {
+        return this._provider.clone(id);
+    }
+    idToString(id) {
+        return this._provider.idToString(id);
+    }
+    idFromString(str) {
+        return this._provider.idFromString(str);
+    }
+    // Add strongly-typed convenience methods
+    /**
+     * Generate a new ID with strong typing.
+     * This is equivalent to generate() + fromBytes() but returns the native type directly.
+     */
+    generateTyped() {
+        const bytes = this.generate();
+        return this.fromBytes(bytes);
+    }
+    /**
+     * Validate an ID with strong typing.
+     * Accepts the native ID type and validates it.
+     */
+    validateTyped(id) {
+        const bytes = this.toBytes(id);
+        return this.validate(bytes);
+    }
+    /**
+     * Serialize an ID to string with strong typing.
+     * Accepts the native ID type directly.
+     */
+    serializeTyped(id) {
+        return this.idToString(id);
+    }
+    /**
+     * Deserialize a string to ID with strong typing.
+     * Returns the native ID type directly.
+     */
+    deserializeTyped(str) {
+        return this.idFromString(str);
+    }
+}
+exports.TypedIdProviderWrapper = TypedIdProviderWrapper;
+/**
+ * Get a strongly-typed ID provider with enhanced convenience methods.
+ * This provides the most ergonomic API for strongly-typed ID operations.
+ *
+ * @example
+ * ```typescript
+ * // Direct replacement for Constants.idProvider with strong typing
+ * const idProvider = getEnhancedIdProvider<ObjectId>();
+ *
+ * // All original methods work the same
+ * const bytes = idProvider.generate(); // Uint8Array
+ * const isValid = idProvider.validate(bytes); // boolean
+ *
+ * // Plus new strongly-typed methods
+ * const objectId = idProvider.generateTyped(); // ObjectId - strongly typed!
+ * const valid = idProvider.validateTyped(objectId); // boolean
+ * const serialized = idProvider.serializeTyped(objectId); // string
+ * const deserialized = idProvider.deserializeTyped(serialized); // ObjectId
+ * ```
+ */
+function getEnhancedIdProvider(key) {
+    const provider = getTypedIdProvider(key);
+    return new TypedIdProviderWrapper(provider);
+}
+/**
+ * Get a typed configuration from the registry.
+ * The type parameter must match the actual ID provider type.
+ *
+ * @example
+ * ```typescript
+ * // For ObjectId configurations
+ * const config = getTypedConfiguration<ObjectId>();
+ * const id = config.generateId(); // Returns ObjectId
+ *
+ * // For GUID configurations
+ * const guidConfig = getTypedConfiguration<GuidV4>('my-guid-config');
+ * const guid = guidConfig.generateId(); // Returns GuidV4
+ * ```
+ */
+function getTypedConfiguration(key) {
+    const constants = (0, constants_1.getRuntimeConfiguration)(key);
+    return new TypedConfiguration(constants);
+}
+/**
+ * Type-safe configuration builder that infers the ID provider type.
+ * This provides the strongest typing by inferring TID from the idProvider.
+ */
+function createTypedConfiguration(config) {
+    const constants = (0, constants_1.createRuntimeConfiguration)(config);
+    return new TypedConfiguration(constants);
+}
+//# sourceMappingURL=typed-configuration.js.map

package/src/typed-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-configuration.js","sourceRoot":"","sources":["../../../../packages/digitaldefiance-ecies-lib/src/typed-configuration.ts"],"names":[],"mappings":"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"}