@bitblit/ratchet-aws 4.0.98-alpha → 4.0.102-alpha

package/dist/{types/expiring-code → 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/expiring-code → 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/expiring-code → 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/expiring-code → 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/expiring-code → 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/dist/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 export class ExpiringCodeRatchet {
+    provider;
     constructor(provider) {
         this.provider = provider;
     }

package/dist/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/expiring-code → 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/expiring-code → expiring-code}/s3-expiring-code-provider.js

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

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

@@ -0,0 +1,46 @@
+import { JestRatchet } from '@bitblit/ratchet-jest/dist/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/iam → 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/iam → iam}/aws-credentials-ratchet.js

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

package/dist/{es/lambda → 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/model → 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/dist/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/dist/model/dynamo/doc-put-item-command-input.js

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

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

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

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

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

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

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

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

@@ -1,7 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/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/runtime-parameter → 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/dist/runtime-parameter/cached-stored-runtime-parameter.js

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

package/dist/{types/runtime-parameter → 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/runtime-parameter → 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/dist/lang/require-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class DynamoRuntimeParameterProvider {
+    dynamo;
+    tableName;
     constructor(dynamo, tableName) {
         this.dynamo = dynamo;
         this.tableName = tableName;

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

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

package/dist/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/dist/jest/jest-ratchet.js';
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/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/runtime-parameter → 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/runtime-parameter → 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/dist/lang/require-ratchet.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/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/dist/runtime-parameter/global-variable-override-runtime-parameter-provider.spec.d.ts

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

package/dist/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/dist/jest/jest-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/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/runtime-parameter → 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/runtime-parameter → runtime-parameter}/memory-runtime-parameter-provider.js

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

package/dist/{types/runtime-parameter → 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/dist/runtime-parameter/runtime-parameter-provider.js

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

package/dist/{types/runtime-parameter → 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/runtime-parameter → 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/dist/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/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/dist/runtime-parameter/runtime-parameter-ratchet.spec.d.ts

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

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

@@ -0,0 +1,39 @@
+import { RuntimeParameterRatchet } from './runtime-parameter-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/dist/logger/logger-level-name.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/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/dist/runtime-parameter/stored-runtime-parameter.js

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

package/dist/{types/s3 → 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/s3 → 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/dist/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { StopWatch } from '@bitblit/ratchet-common/dist/lang/stop-watch.js';
+import { StreamRatchet } from '@bitblit/ratchet-common/dist/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/dist/s3/s3-cache-ratchet.spec.d.ts

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

package/dist/s3/s3-cache-ratchet.spec.js

@@ -0,0 +1,97 @@
+import { CopyObjectCommand, CreateMultipartUploadCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client, UploadPartCommand, } from '@aws-sdk/client-s3';
+import { S3CacheRatchet } from './s3-cache-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { StreamRatchet } from '@bitblit/ratchet-common/dist/stream/stream-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+import { jest } from '@jest/globals';
+jest.mock('@aws-sdk/s3-request-presigner', () => ({
+    getSignedUrl: jest.fn(() => Promise.resolve('https://test.link/test.jpg')),
+}));
+let mockS3 = null;
+let mockS3OtherAccount = null;
+describe('#fileExists', function () {
+    mockS3 = mockClient(S3Client);
+    mockS3OtherAccount = mockClient(S3Client);
+    beforeEach(() => {
+        mockS3.reset();
+        mockS3OtherAccount.reset();
+    });
+    it('should return false for files that do not exist', async () => {
+        mockS3.on(HeadObjectCommand).rejects({ statusCode: 404, $metadata: null });
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.fileExists('test-missing-file');
+        expect(out).toEqual(false);
+    });
+    xit('should create a expiring link', async () => {
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.preSignedDownloadUrlForCacheFile('test.jpg', 300);
+        expect(out).toEqual('https://test.link/test.jpg');
+    });
+    it('should copy an object', async () => {
+        mockS3.on(CopyObjectCommand).resolves({});
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const out = await cache.quietCopyFile('test.png', 'test2.png');
+        expect(out).toBeTruthy();
+    });
+    xit('should copy a file to s3', async () => {
+        mockS3.on(PutObjectCommand).resolves({});
+        mockS3.on(CreateMultipartUploadCommand).resolves({ UploadId: '1' });
+        mockS3.on(UploadPartCommand).resolves({ ETag: '1' });
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const stream = StreamRatchet.stringToWebReadableStream(StringRatchet.createRandomHexString(1024 * 1024 * 6));
+        const out = await cache.writeStreamToCacheFile('s3-cache-ratchet.spec.ts', stream, {
+            ContentType: 'text/typescript',
+        });
+        Logger.info('Calls: %j', mockS3.calls());
+        expect(out).toBeTruthy();
+    });
+    it('should pull a file as a string', async () => {
+        async function createNew() {
+            return {
+                Body: {
+                    transformToByteArray: async () => Promise.resolve(StringRatchet.stringToUint8Array(JSON.stringify({ test: StringRatchet.createRandomHexString(128) }))),
+                    transformToString: async () => Promise.resolve(JSON.stringify({ test: StringRatchet.createRandomHexString(128) })),
+                },
+                $metadata: null,
+            };
+        }
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const cache = new S3CacheRatchet(mockS3, 'test-bucket');
+        const fileName = 'test-file.json';
+        const outBuf = await cache.fetchCacheFileAsBuffer(fileName);
+        expect(outBuf).toBeTruthy();
+        expect(outBuf.length).toBeGreaterThan(100);
+        mockS3.reset();
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const outString = await cache.fetchCacheFileAsString(fileName);
+        expect(outString).toBeTruthy();
+        expect(outString.length).toBeGreaterThan(100);
+        mockS3.reset();
+        mockS3.on(GetObjectCommand).resolves(createNew());
+        const outObject = await cache.fetchCacheFileAsObject(fileName);
+        expect(outObject).toBeTruthy();
+        expect(outObject['test']).toBeTruthy();
+    });
+    xit('should sync 2 folders', async () => {
+        const cache1 = new S3CacheRatchet(mockS3, 'test1');
+        const cache2 = new S3CacheRatchet(mockS3, 'test2');
+        const out = await cache1.synchronize('src/', 'dst/', cache2);
+        expect(out).not.toBeNull();
+    }, 60_000);
+    xit('should list direct children past 1000', async () => {
+        const s3 = new S3Client({ region: 'us-east-1' });
+        const cache = new S3CacheRatchet(s3, 'test-bucket');
+        const out = await cache.directChildrenOfPrefix('test/aws/test-path-with-lots-of-childen/');
+        expect(out).toBeTruthy();
+        expect(out.length).toBeGreaterThan(1000);
+        Logger.info('Got: %s', out);
+        expect(out).toBeTruthy();
+    });
+    xit('should sync cross-account', async () => {
+        const cache1 = new S3CacheRatchet(mockS3, 'bucket1');
+        const cache2 = new S3CacheRatchet(mockS3OtherAccount, 'bucket2');
+        const res = await cache1.synchronize('test1/', 'test2/', cache2, true);
+        expect(res).not.toBeNull();
+    }, 50_000);
+});

package/dist/{types/s3 → s3}/s3-cache-to-local-disk-ratchet.d.ts

@@ -1,8 +1,5 @@
-/// <reference types="node" />
-import { S3CacheRatchet } from './s3-cache-ratchet';
-/**
- * Use this when you want a lambda to cache a remote S3 bucket locally on disk for faster access
- */
+/// <reference types="node" resolution-mode="require"/>
+import { S3CacheRatchet } from './s3-cache-ratchet.js';
 export declare class S3CacheToLocalDiskRatchet {
     private s3;
     private tmpFolder;