@bitblit/ratchet-aws 4.0.99-alpha → 4.0.103-alpha

package/{dist/types → lib}/environment/ssm-environment-service-provider.d.ts

@@ -1,8 +1,4 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
-/**
- * Service for reading environmental variables
- * Also hides the decryption detail from higher up services
- */
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
 export declare class SsmEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
     private region;
     private ssmEncrypted;

package/{dist/es → lib}/environment/ssm-environment-service-provider.js

@@ -1,10 +1,13 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
 import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
 export class SsmEnvironmentServiceProvider {
+    region;
+    ssmEncrypted;
+    ssm;
     constructor(region = 'us-east-1', ssmEncrypted = true) {
         this.region = region;
         this.ssmEncrypted = ssmEncrypted;
@@ -28,7 +31,7 @@ export class SsmEnvironmentServiceProvider {
             const errCode = err['code'] || '';
             if (errCode.toLowerCase().indexOf('throttlingexception') !== -1) {
                 Logger.warn('Throttled while trying to read parameters - waiting 1 second before allowing retry');
-                await PromiseRatchet.wait(1000);
+                await PromiseRatchet.wait(1_000);
             }
             else if (errCode.toLowerCase().indexOf('parameternotfound') !== -1) {
                 const errMsg = Logger.warn('AWS could not find parameter %s - are you using the right AWS key?', name);

package/{dist/types → lib}/expiring-code/dynamo-expiring-code-provider.d.ts

@@ -1,7 +1,7 @@
-import { ExpiringCodeProvider } from './expiring-code-provider';
-import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
-import { ExpiringCode } from './expiring-code';
-import { DynamoTableRatchet } from '../dynamodb/dynamo-table-ratchet';
+import { ExpiringCodeProvider } from './expiring-code-provider.js';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
+import { ExpiringCode } from './expiring-code.js';
+import { DynamoTableRatchet } from '../dynamodb/dynamo-table-ratchet.js';
 export declare class DynamoExpiringCodeProvider implements ExpiringCodeProvider {
     private tableName;
     private dynamoRatchet;

package/{dist/es → lib}/expiring-code/dynamo-expiring-code-provider.js

@@ -1,4 +1,6 @@
 export class DynamoExpiringCodeProvider {
+    tableName;
+    dynamoRatchet;
     constructor(tableName, dynamoRatchet) {
         this.tableName = tableName;
         this.dynamoRatchet = dynamoRatchet;

package/{dist/types → lib}/expiring-code/expiring-code-provider.d.ts

@@ -1,4 +1,4 @@
-import { ExpiringCode } from './expiring-code';
+import { ExpiringCode } from './expiring-code.js';
 export interface ExpiringCodeProvider {
     storeCode(code: ExpiringCode): Promise<boolean>;
     checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean>;

package/{dist/types → lib}/expiring-code/expiring-code-ratchet.d.ts

@@ -1,9 +1,6 @@
-import { ExpiringCodeProvider } from './expiring-code-provider';
-import { ExpiringCodeParams } from './expiring-code-params';
-import { ExpiringCode } from './expiring-code';
-/**
- * Supports creating and checking single use codes
- */
+import { ExpiringCodeProvider } from './expiring-code-provider.js';
+import { ExpiringCodeParams } from './expiring-code-params.js';
+import { ExpiringCode } from './expiring-code.js';
 export declare class ExpiringCodeRatchet {
     private provider;
     constructor(provider: ExpiringCodeProvider);

package/{dist/es → lib}/expiring-code/expiring-code-ratchet.js

@@ -1,6 +1,7 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class ExpiringCodeRatchet {
+    provider;
     constructor(provider) {
         this.provider = provider;
     }

package/lib/expiring-code/expiring-code-ratchet.spec.js

@@ -0,0 +1,7 @@
+import { ExpiringCodeRatchet } from './expiring-code-ratchet.js';
+describe('#ExpiringCodeRatchet', () => {
+    it('Should generate valid codes', async () => {
+        const output = ExpiringCodeRatchet.generateCode({ context: 'test', length: 5, timeToLiveSeconds: 10, alphabet: 'A' });
+        expect(output.code).toEqual('AAAAA');
+    });
+});

package/{dist/types → lib}/expiring-code/s3-expiring-code-provider.d.ts

@@ -1,6 +1,6 @@
-import { ExpiringCodeProvider } from './expiring-code-provider';
-import { ExpiringCode } from './expiring-code';
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+import { ExpiringCodeProvider } from './expiring-code-provider.js';
+import { ExpiringCode } from './expiring-code.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
 import { PutObjectOutput } from '@aws-sdk/client-s3';
 export declare class S3ExpiringCodeProvider implements ExpiringCodeProvider {
     private s3CacheRatchet;

package/{dist/es → lib}/expiring-code/s3-expiring-code-provider.js

@@ -1,5 +1,8 @@
-import { Logger, RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class S3ExpiringCodeProvider {
+    s3CacheRatchet;
+    keyName;
     constructor(s3CacheRatchet, keyName) {
         this.s3CacheRatchet = s3CacheRatchet;
         this.keyName = keyName;

package/lib/expiring-code/s3-expiring-code-provider.spec.js

@@ -0,0 +1,46 @@
+import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
+import { S3ExpiringCodeProvider } from './s3-expiring-code-provider.js';
+import { jest } from '@jest/globals';
+let mockS3Ratchet;
+const testCode = { code: '12345', context: 'ctx', expiresEpochMS: Date.now() + 100_000, tags: ['tag1'] };
+const testCode2 = { code: '45678', context: 'ctx', expiresEpochMS: Date.now() + 100_000, tags: ['tag1'] };
+describe('#S3ExpiringCodeProvider', () => {
+    beforeEach(() => {
+        mockS3Ratchet = JestRatchet.mock(jest.fn);
+        mockS3Ratchet.getDefaultBucket.mockReturnValue('TEST-BUCKET');
+    });
+    it('Should fetch file', async () => {
+        const val = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+        const output = await val.fetchFile();
+        expect(output).not.toBeFalsy();
+        expect(output.data).not.toBeFalsy();
+        expect(output.lastModifiedEpochMS).not.toBeFalsy();
+    });
+    it('Should update file', async () => {
+        const val = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+        mockS3Ratchet.writeObjectToCacheFile.mockResolvedValue({});
+        const wrote = await val.updateFile([testCode]);
+        expect(wrote).not.toBeFalsy();
+    });
+    it('Should check code', async () => {
+        mockS3Ratchet.fetchCacheFileAsObject.mockResolvedValue({
+            data: [testCode],
+            lastModifiedEpochMS: 1234,
+        });
+        const val = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+        const testValidCode = await val.checkCode('12345', 'ctx', false);
+        const testInvalidCode = await val.checkCode('09876', 'ctx', false);
+        expect(testValidCode).toBeTruthy();
+        expect(testInvalidCode).toBeFalsy();
+    });
+    it('Should store code', async () => {
+        mockS3Ratchet.fetchCacheFileAsObject.mockResolvedValue({
+            data: [testCode],
+            lastModifiedEpochMS: 1234,
+        });
+        mockS3Ratchet.writeObjectToCacheFile.mockResolvedValue({});
+        const val = new S3ExpiringCodeProvider(mockS3Ratchet, 'test.json');
+        const output = await val.storeCode(testCode2);
+        expect(output).toBeTruthy();
+    });
+});

package/{dist/types → lib}/iam/aws-credentials-ratchet.d.ts

@@ -1,8 +1,3 @@
-/**
- * Ratchet for manipulating credentials
- *
- * Mainly here so I don't have to remember certain specific AWS environmental variable names
- */
 export declare class AwsCredentialsRatchet {
     private constructor();
     static applySetProfileEnvironmentalVariable(newProfile: string): void;

package/{dist/es → lib}/iam/aws-credentials-ratchet.js

@@ -1,4 +1,5 @@
-import { ErrorRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class AwsCredentialsRatchet {
     constructor() { }
     static applySetProfileEnvironmentalVariable(newProfile) {

package/{dist/es → lib}/lambda/lambda-event-type-guards.js

@@ -1,4 +1,4 @@
-import { LambdaEventDetector } from './lambda-event-detector';
+import { LambdaEventDetector } from './lambda-event-detector.js';
 export class LambdaEventTypeGuards {
     static isValidCronEvent(event) {
         return LambdaEventDetector.isValidCronEvent(event);

package/{dist/types → lib}/model/cloud-watch-metrics-minute-level-dynamo-count-request.d.ts

@@ -1,5 +1,5 @@
-import { KeyValue } from '@bitblit/ratchet-common';
-import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
+import { KeyValue } from '@bitblit/ratchet-common/lib/lang/key-value.js';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
 import { QueryInput, ScanCommandInput } from '@aws-sdk/client-dynamodb';
 export interface CloudWatchMetricsMinuteLevelDynamoCountRequest {
     dynamoRatchet: DynamoRatchet;

package/lib/model/dynamo/doc-put-item-command-input.js

@@ -0,0 +1 @@
+export {};

package/lib/model/dynamo/doc-query-command-input.js

@@ -0,0 +1 @@
+export {};

package/lib/model/dynamo/doc-scan-command-input.js

@@ -0,0 +1 @@
+export {};

package/lib/model/dynamo/doc-update-item-command-input.js

@@ -0,0 +1 @@
+export {};

package/{dist/es → lib}/route53/route-53-ratchet.js

@@ -1,7 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 import { ChangeResourceRecordSetsCommand, waitUntilResourceRecordSetsChanged, } from '@aws-sdk/client-route-53';
 import { WaiterState } from '@aws-sdk/util-waiter';
 export class Route53Ratchet {
+    route53;
+    hostedZoneId;
     constructor(route53, hostedZoneId) {
         this.route53 = route53;
         this.hostedZoneId = hostedZoneId;

package/{dist/types → lib}/runtime-parameter/cached-stored-runtime-parameter.d.ts

@@ -1,4 +1,4 @@
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
 export interface CachedStoredRuntimeParameter extends StoredRuntimeParameter {
     storedEpochMS: number;
 }

package/lib/runtime-parameter/cached-stored-runtime-parameter.js

@@ -0,0 +1 @@
+export {};

package/{dist/types → lib}/runtime-parameter/dynamo-runtime-parameter-provider.d.ts

@@ -1,6 +1,6 @@
-import { RuntimeParameterProvider } from './runtime-parameter-provider';
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
-import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
 export declare class DynamoRuntimeParameterProvider implements RuntimeParameterProvider {
     private dynamo;
     private tableName;

package/{dist/es → lib}/runtime-parameter/dynamo-runtime-parameter-provider.js

@@ -1,6 +1,8 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { Logger } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 export class DynamoRuntimeParameterProvider {
+    dynamo;
+    tableName;
     constructor(dynamo, tableName) {
         this.dynamo = dynamo;
         this.tableName = tableName;

package/lib/runtime-parameter/dynamo-runtime-parameter-provider.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime-parameter/dynamo-runtime-parameter-provider.spec.js

@@ -0,0 +1,49 @@
+import { DynamoRuntimeParameterProvider } from './dynamo-runtime-parameter-provider.js';
+import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { jest } from '@jest/globals';
+let mockDynamoRatchet;
+const testEntry = { groupId: 'test', paramKey: 'test', paramValue: '15', ttlSeconds: 0.5 };
+const testEntry2 = { groupId: 'test', paramKey: 'test1', paramValue: '20', ttlSeconds: 0.5 };
+describe('#runtimeParameterRatchet', function () {
+    beforeEach(() => {
+        mockDynamoRatchet = JestRatchet.mock(jest.fn);
+    });
+    it('fetch and cache a runtime parameter', async () => {
+        Logger.setLevel(LoggerLevelName.silly);
+        const tableName = 'default-table';
+        mockDynamoRatchet.simpleGet.mockResolvedValue(testEntry);
+        mockDynamoRatchet.simplePut.mockResolvedValue({});
+        const drpp = new DynamoRuntimeParameterProvider(mockDynamoRatchet, tableName);
+        const rpr = new RuntimeParameterRatchet(drpp);
+        const stored = await rpr.storeParameter('test', 'test1', 15, 0.5);
+        Logger.info('Stored : %j', stored);
+        const cache1 = await rpr.fetchParameter('test', 'test1');
+        const cache1a = await rpr.fetchParameter('test', 'test1');
+        const cache1b = await rpr.fetchParameter('test', 'test1');
+        expect(cache1).toEqual(15);
+        expect(cache1a).toEqual(15);
+        expect(cache1b).toEqual(15);
+        await PromiseRatchet.wait(1000);
+        const cache2 = await rpr.fetchParameter('test', 'test1');
+        expect(cache2).toEqual(15);
+        mockDynamoRatchet.simpleGet.mockResolvedValue(null);
+        const cacheMiss = await rpr.fetchParameter('test', 'test-miss');
+        expect(cacheMiss).toBeNull();
+        const cacheDefault = await rpr.fetchParameter('test', 'test-miss', 27);
+        expect(cacheDefault).toEqual(27);
+    }, 30_000);
+    it('reads underlying entries', async () => {
+        Logger.setLevel(LoggerLevelName.silly);
+        const tableName = 'default-table';
+        mockDynamoRatchet.fullyExecuteQuery.mockResolvedValue([testEntry, testEntry2]);
+        const drpp = new DynamoRuntimeParameterProvider(mockDynamoRatchet, tableName);
+        const rpr = new RuntimeParameterRatchet(drpp);
+        const vals = await rpr.readUnderlyingEntries('test');
+        expect(vals).not.toBeFalsy();
+        expect(vals.length).toEqual(2);
+    }, 30_000);
+});

package/{dist/types → lib}/runtime-parameter/global-variable-override-runtime-parameter-provider.d.ts

@@ -1,12 +1,5 @@
-import { RuntimeParameterProvider } from './runtime-parameter-provider';
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
-/**
- * Provides parameters for a runtime parameter from an global (ie, process.env or global.xx) variable, where the key follows
- * a given format
- *
- * "Simple" because it forces all ttls to be the same value (ignores what is passed in) so that the
- * envvar itself can be just a string instead of a complex value
- */
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
 export declare class GlobalVariableOverrideRuntimeParameterProvider implements RuntimeParameterProvider {
     private wrapped;
     private options;

package/{dist/es → lib}/runtime-parameter/global-variable-override-runtime-parameter-provider.js

@@ -1,14 +1,16 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class GlobalVariableOverrideRuntimeParameterProvider {
+    wrapped;
+    options = {
+        globalTTL: 1,
+        separator: '.',
+        prefix: 'RuntimeEnv-',
+        suffix: '',
+    };
     constructor(wrapped, opts) {
         this.wrapped = wrapped;
-        this.options = {
-            globalTTL: 1,
-            separator: '.',
-            prefix: 'RuntimeEnv-',
-            suffix: '',
-        };
         RequireRatchet.notNullOrUndefined(this.wrapped, 'wrapped');
         RequireRatchet.notNullOrUndefined(global?.process?.env, '"process" not found - this only runs in Node, not the browser');
         if (opts) {

package/lib/runtime-parameter/global-variable-override-runtime-parameter-provider.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime-parameter/global-variable-override-runtime-parameter-provider.spec.js

@@ -0,0 +1,37 @@
+import { DynamoRuntimeParameterProvider } from './dynamo-runtime-parameter-provider.js';
+import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { GlobalVariableOverrideRuntimeParameterProvider } from './global-variable-override-runtime-parameter-provider.js';
+import { jest } from '@jest/globals';
+let mockDynamoRatchet;
+const testEntry = { groupId: 'test', paramKey: 'test', paramValue: '15', ttlSeconds: 0.5 };
+const testEntry2 = { groupId: 'test', paramKey: 'test1', paramValue: '"not-overridden"', ttlSeconds: 0.5 };
+describe('#globalVariableOverrideRuntimeParameterProvider', function () {
+    beforeEach(() => {
+        mockDynamoRatchet = JestRatchet.mock(jest.fn);
+    });
+    it('reads underlying entries', async () => {
+        Logger.setLevel(LoggerLevelName.silly);
+        mockDynamoRatchet.simpleGet.mockResolvedValue(testEntry2);
+        const drpp = new DynamoRuntimeParameterProvider(mockDynamoRatchet, 'test-table');
+        const er = new GlobalVariableOverrideRuntimeParameterProvider(drpp, {
+            globalTTL: 1,
+            separator: '.',
+            prefix: 'p-',
+            suffix: null,
+        });
+        process.env[er.generateName('test', 'test1')] = '"override"';
+        const rpr = new RuntimeParameterRatchet(er);
+        const root = await drpp.readParameter('test', 'test1');
+        const override = await er.readParameter('test', 'test1');
+        const fetched = await rpr.fetchParameter('test', 'test1');
+        expect(root).not.toBeNull();
+        expect(override).not.toBeNull();
+        expect(fetched).not.toBeNull();
+        expect(root.paramValue).toEqual('"not-overridden"');
+        expect(override.paramValue).toEqual('"override"');
+        expect(fetched).toEqual('override');
+    }, 30_000);
+});

package/{dist/types → lib}/runtime-parameter/memory-runtime-parameter-provider.d.ts

@@ -1,9 +1,5 @@
-import { RuntimeParameterProvider } from './runtime-parameter-provider';
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
-/**
- * Very simple class, basically here just for unit testing although I suppose you could
- * use it for something else
- */
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
 export declare class MemoryRuntimeParameterProvider implements RuntimeParameterProvider {
     private data;
     constructor(data?: Promise<Record<string, StoredRuntimeParameter>>);

package/{dist/es → lib}/runtime-parameter/memory-runtime-parameter-provider.js

@@ -1,5 +1,6 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
 export class MemoryRuntimeParameterProvider {
+    data;
     constructor(data = Promise.resolve({})) {
         this.data = data;
     }

package/{dist/types → lib}/runtime-parameter/runtime-parameter-provider.d.ts

@@ -1,9 +1,4 @@
-/**
- * Classes implementing RuntimeParameterProvider offer the ability to fetch a runtime parameter
- * object from _somewhere_
- * They do NOT handle local caching - the RuntimeParameterRatchet does that
- */
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
 export interface RuntimeParameterProvider {
     readParameter(groupId: string, paramKey: string): Promise<StoredRuntimeParameter>;
     readAllParametersForGroup(groupId: string): Promise<StoredRuntimeParameter[]>;

package/lib/runtime-parameter/runtime-parameter-provider.js

@@ -0,0 +1 @@
+export {};

package/{dist/types → lib}/runtime-parameter/runtime-parameter-ratchet.d.ts

@@ -1,5 +1,5 @@
-import { RuntimeParameterProvider } from './runtime-parameter-provider';
-import { StoredRuntimeParameter } from './stored-runtime-parameter';
+import { RuntimeParameterProvider } from './runtime-parameter-provider.js';
+import { StoredRuntimeParameter } from './stored-runtime-parameter.js';
 export declare class RuntimeParameterRatchet {
     private provider;
     private cache;

package/{dist/es → lib}/runtime-parameter/runtime-parameter-ratchet.js

@@ -1,9 +1,10 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class RuntimeParameterRatchet {
+    provider;
+    cache = new Map();
     constructor(provider) {
         this.provider = provider;
-        this.cache = new Map();
         RequireRatchet.notNullOrUndefined(this.provider);
     }
     async fetchParameter(groupId, paramKey, defaultValue = null, forceFreshRead = false) {

package/lib/runtime-parameter/runtime-parameter-ratchet.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime-parameter/runtime-parameter-ratchet.spec.js

@@ -0,0 +1,39 @@
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { MemoryRuntimeParameterProvider } from './memory-runtime-parameter-provider.js';
+const testEntry = { groupId: 'test', paramKey: 'test', paramValue: '15', ttlSeconds: 0.5 };
+const testEntry2 = { groupId: 'test', paramKey: 'test1', paramValue: '20', ttlSeconds: 0.5 };
+describe('#runtimeParameterRatchet', function () {
+    it('fetch and cache a runtime parameter', async () => {
+        Logger.setLevel(LoggerLevelName.silly);
+        const mp = new MemoryRuntimeParameterProvider();
+        const rpr = new RuntimeParameterRatchet(mp);
+        const stored = await rpr.storeParameter('test', 'test1', 15, 0.5);
+        Logger.info('Stored : %j', stored);
+        const cache1 = await rpr.fetchParameter('test', 'test1');
+        const cache1a = await rpr.fetchParameter('test', 'test1');
+        const cache1b = await rpr.fetchParameter('test', 'test1');
+        expect(cache1).toEqual(15);
+        expect(cache1a).toEqual(15);
+        expect(cache1b).toEqual(15);
+        await PromiseRatchet.wait(1000);
+        const cache2 = await rpr.fetchParameter('test', 'test1');
+        expect(cache2).toEqual(15);
+        const cacheMiss = await rpr.fetchParameter('test', 'test-miss');
+        expect(cacheMiss).toBeNull();
+        const cacheDefault = await rpr.fetchParameter('test', 'test-miss', 27);
+        expect(cacheDefault).toEqual(27);
+    }, 30_000);
+    it('reads underlying entries', async () => {
+        Logger.setLevel(LoggerLevelName.silly);
+        const mrpp = new MemoryRuntimeParameterProvider();
+        await mrpp.writeParameter(testEntry);
+        await mrpp.writeParameter(testEntry2);
+        const rpr = new RuntimeParameterRatchet(mrpp);
+        const vals = await rpr.readUnderlyingEntries('test');
+        expect(vals).not.toBeFalsy();
+        expect(vals.length).toEqual(2);
+    }, 30_000);
+});

package/lib/runtime-parameter/stored-runtime-parameter.js

@@ -0,0 +1 @@
+export {};

package/{dist/types → lib}/s3/s3-cache-ratchet.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { CompleteMultipartUploadCommandOutput, CopyObjectCommandOutput, DeleteObjectCommandOutput, GetObjectCommandOutput, HeadObjectCommandOutput, PutObjectCommandInput, S3Client } from '@aws-sdk/client-s3';
 import { Readable } from 'stream';
 export declare class S3CacheRatchet {
@@ -17,8 +17,7 @@ export declare class S3CacheRatchet {
     fetchCacheFileAsString(key: string, bucket?: string): Promise<string>;
     fetchCacheFileAsObject<T>(key: string, bucket?: string): Promise<T>;
     removeCacheFile(key: string, bucket?: string): Promise<DeleteObjectCommandOutput>;
-    writeObjectToCacheFile(key: string, dataObject: any, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
-    template?: PutObjectCommandInput, bucket?: string): Promise<CompleteMultipartUploadCommandOutput>;
+    writeObjectToCacheFile(key: string, dataObject: any, template?: PutObjectCommandInput, bucket?: string): Promise<CompleteMultipartUploadCommandOutput>;
     writeStringToCacheFile(key: string, dataString: string, template?: PutObjectCommandInput, bucket?: string): Promise<CompleteMultipartUploadCommandOutput>;
     writeStreamToCacheFile(key: string, data: ReadableStream | Readable, template?: PutObjectCommandInput, bucket?: string): Promise<CompleteMultipartUploadCommandOutput>;
     synchronize(srcPrefix: string, targetPrefix: string, targetRatchet?: S3CacheRatchet, recurseSubFolders?: boolean): Promise<string[]>;

package/{dist/es → lib}/s3/s3-cache-ratchet.js

@@ -1,12 +1,14 @@
 import { CopyObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsCommand, NoSuchKey, } from '@aws-sdk/client-s3';
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { StopWatch } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { StopWatch } from '@bitblit/ratchet-common/lib/lang/stop-watch.js';
+import { StreamRatchet } from '@bitblit/ratchet-common/lib/stream/stream-ratchet.js';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { Upload } from '@aws-sdk/lib-storage';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { StreamRatchet } from '@bitblit/ratchet-common';
 export class S3CacheRatchet {
+    s3;
+    defaultBucket;
     constructor(s3, defaultBucket = null) {
         this.s3 = s3;
         this.defaultBucket = defaultBucket;

package/lib/s3/s3-cache-ratchet.spec.d.ts

@@ -0,0 +1 @@
+export {};