@bitblit/ratchet-aws 4.0.115-alpha → 4.0.119-alpha

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

@@ -1,71 +0,0 @@
-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;
-        RequireRatchet.notNullOrUndefined(this.provider);
-    }
-    async fetchParameter(groupId, paramKey, defaultValue = null, forceFreshRead = false) {
-        Logger.debug('Reading parameter %s / %s / Force : %s', groupId, paramKey, forceFreshRead);
-        const cached = this.cache.get(RuntimeParameterRatchet.toCacheStoreKey(groupId, paramKey));
-        let rval = null;
-        const now = new Date().getTime();
-        if (!forceFreshRead && !!cached) {
-            const oldest = !!cached.ttlSeconds ? now - cached.ttlSeconds * 1000 : 0;
-            if (cached.storedEpochMS > oldest) {
-                Logger.silly('Fetched %s / %s from cache', groupId, paramKey);
-                rval = JSON.parse(cached.paramValue);
-            }
-        }
-        if (!rval) {
-            const temp = await this.readUnderlyingEntry(groupId, paramKey);
-            if (!!temp) {
-                this.addToCache(temp);
-                rval = JSON.parse(temp.paramValue);
-            }
-        }
-        rval = rval || defaultValue;
-        return rval;
-    }
-    async fetchAllParametersForGroup(groupId) {
-        const all = await this.readUnderlyingEntries(groupId);
-        const rval = new Map();
-        all.forEach((t) => {
-            rval.set(t.paramKey, JSON.parse(t.paramValue));
-            this.addToCache(t);
-        });
-        return rval;
-    }
-    async readUnderlyingEntry(groupId, paramKey) {
-        return this.provider.readParameter(groupId, paramKey);
-    }
-    async readUnderlyingEntries(groupId) {
-        return this.provider.readAllParametersForGroup(groupId);
-    }
-    async storeParameter(groupId, paramKey, paramValue, ttlSeconds) {
-        const toStore = {
-            groupId: groupId,
-            paramKey: paramKey,
-            paramValue: JSON.stringify(paramValue),
-            ttlSeconds: ttlSeconds,
-        };
-        const wrote = await this.provider.writeParameter(toStore);
-        return this.provider.readParameter(groupId, paramKey);
-    }
-    static toCacheStoreKey(groupId, paramKey) {
-        return groupId + ':::' + paramKey;
-    }
-    addToCache(temp) {
-        if (!!temp) {
-            const now = new Date().getTime();
-            const toStore = Object.assign({ storedEpochMS: now }, temp);
-            this.cache.set(RuntimeParameterRatchet.toCacheStoreKey(temp.groupId, temp.paramKey), toStore);
-        }
-    }
-    clearCache() {
-        Logger.debug('Clearing runtime parameter cache');
-        this.cache = new Map();
-    }
-}

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

@@ -1,39 +0,0 @@
-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

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

package/lib/s3/s3-cache-ratchet.js

@@ -1,330 +0,0 @@
-import { CopyObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsCommand, NoSuchKey, } from '@aws-sdk/client-s3';
-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';
-export class S3CacheRatchet {
-    s3;
-    defaultBucket;
-    constructor(s3, defaultBucket = null) {
-        this.s3 = s3;
-        this.defaultBucket = defaultBucket;
-        RequireRatchet.notNullOrUndefined(this.s3, 's3');
-    }
-    static applyCacheControlMaxAge(input, seconds) {
-        if (input && seconds) {
-            input.CacheControl = 'max-age=' + seconds;
-        }
-        return input;
-    }
-    static applyUserMetaData(input, key, value) {
-        if (input && StringRatchet.trimToNull(key) && StringRatchet.trimToNull(value)) {
-            input.Metadata = input.Metadata || {};
-            input.Metadata[key] = value;
-        }
-        return input;
-    }
-    getDefaultBucket() {
-        return this.defaultBucket;
-    }
-    getS3Client() {
-        return this.s3;
-    }
-    async fileExists(key, bucket = null) {
-        try {
-            const head = await this.fetchMetaForCacheFile(key, this.bucketVal(bucket));
-            return !!head;
-        }
-        catch (err) {
-            Logger.silly('Error calling file exists (as expected) %s', err);
-            return false;
-        }
-    }
-    async fetchCacheFileAsS3GetObjectCommandOutput(key, bucket = null) {
-        let rval = null;
-        try {
-            const params = {
-                Bucket: this.bucketVal(bucket),
-                Key: key,
-            };
-            rval = await this.s3.send(new GetObjectCommand(params));
-        }
-        catch (err) {
-            if (err instanceof NoSuchKey) {
-                Logger.debug('Key %s not found - returning null', key);
-                rval = null;
-            }
-            else {
-                throw err;
-            }
-        }
-        return rval;
-    }
-    async fetchCacheFileAsReadableStream(key, bucket = null) {
-        const out = await this.fetchCacheFileAsS3GetObjectCommandOutput(key, bucket);
-        return out.Body.transformToWebStream();
-    }
-    async fetchCacheFileAsBuffer(key, bucket = null) {
-        let rval = null;
-        const out = await this.fetchCacheFileAsS3GetObjectCommandOutput(key, bucket);
-        if (out?.Body) {
-            const tmp = await out.Body.transformToByteArray();
-            rval = Buffer.from(tmp);
-        }
-        return rval;
-    }
-    async fetchCacheFileAsString(key, bucket = null) {
-        let rval = null;
-        const out = await this.fetchCacheFileAsS3GetObjectCommandOutput(key, bucket);
-        if (out?.Body) {
-            rval = await out.Body.transformToString();
-        }
-        return rval;
-    }
-    async fetchCacheFileAsObject(key, bucket = null) {
-        const value = await this.fetchCacheFileAsString(key, bucket);
-        return value ? JSON.parse(value) : null;
-    }
-    async removeCacheFile(key, bucket = null) {
-        let rval = null;
-        const params = {
-            Bucket: this.bucketVal(bucket),
-            Key: key,
-        };
-        try {
-            rval = await this.s3.send(new DeleteObjectCommand(params));
-        }
-        catch (err) {
-            if (err && err['statusCode'] == 404) {
-                Logger.info('Swallowing 404 deleting missing object %s %s', bucket, key);
-                rval = null;
-            }
-            else {
-                throw err;
-            }
-        }
-        return rval;
-    }
-    async writeObjectToCacheFile(key, dataObject, template, bucket) {
-        const json = JSON.stringify(dataObject);
-        return this.writeStringToCacheFile(key, json, template, bucket);
-    }
-    async writeStringToCacheFile(key, dataString, template, bucket) {
-        const stream = StreamRatchet.stringToWebReadableStream(dataString);
-        return this.writeStreamToCacheFile(key, stream, template, bucket);
-    }
-    async writeStreamToCacheFile(key, data, template, bucket) {
-        const params = Object.assign({}, template || {}, {
-            Bucket: this.bucketVal(bucket),
-            Key: key,
-            Body: data,
-        });
-        const upload = new Upload({
-            client: this.s3,
-            params: params,
-            tags: [],
-            queueSize: 4,
-            partSize: 1024 * 1024 * 5,
-            leavePartsOnError: false,
-        });
-        upload.on('httpUploadProgress', (progress) => {
-            Logger.info('Uploading : %s', progress);
-        });
-        const result = await upload.done();
-        return result;
-    }
-    async synchronize(srcPrefix, targetPrefix, targetRatchet = this, recurseSubFolders = false) {
-        RequireRatchet.notNullOrUndefined(srcPrefix, 'srcPrefix');
-        RequireRatchet.notNullOrUndefined(targetPrefix, 'targetPrefix');
-        RequireRatchet.true(srcPrefix.endsWith('/'), 'srcPrefix must end in /');
-        RequireRatchet.true(targetPrefix.endsWith('/'), 'targetPrefix must end in /');
-        let rval = [];
-        const sourceFiles = await this.directChildrenOfPrefix(srcPrefix);
-        const targetFiles = await targetRatchet.directChildrenOfPrefix(targetPrefix);
-        const sw = new StopWatch();
-        for (let i = 0; i < sourceFiles.length; i++) {
-            const sourceFile = sourceFiles[i];
-            Logger.info('Processing %s : %s', sourceFile, sw.dumpExpected(i / sourceFiles.length));
-            if (sourceFile.endsWith('/')) {
-                if (recurseSubFolders) {
-                    Logger.info('%s is a subfolder - recursing');
-                    const subs = await this.synchronize(srcPrefix + sourceFile, targetPrefix + sourceFile, targetRatchet, recurseSubFolders);
-                    Logger.info('Got %d back from %s', subs.length, sourceFile);
-                    rval = rval.concat(subs);
-                }
-                else {
-                    Logger.info('%s is a subfolder and recurse not specified - skipping', sourceFile);
-                }
-            }
-            else {
-                let shouldCopy = true;
-                const srcMeta = await this.fetchMetaForCacheFile(srcPrefix + sourceFile);
-                if (targetFiles.includes(sourceFile)) {
-                    const targetMeta = await targetRatchet.fetchMetaForCacheFile(targetPrefix + sourceFile);
-                    if (srcMeta.ETag === targetMeta.ETag) {
-                        Logger.debug('Skipping - identical');
-                        shouldCopy = false;
-                    }
-                }
-                if (shouldCopy) {
-                    Logger.debug('Copying...');
-                    const srcStream = await this.fetchCacheFileAsReadableStream(srcPrefix + sourceFile);
-                    try {
-                        const written = await targetRatchet.writeStreamToCacheFile(targetPrefix + sourceFile, srcStream, srcMeta, undefined);
-                        Logger.silly('Write result : %j', written);
-                        rval.push(sourceFile);
-                    }
-                    catch (err) {
-                        Logger.error('Failed to sync : %s : %s', sourceFile, err);
-                    }
-                }
-            }
-        }
-        Logger.info('Found %d files, copied %d', sourceFiles.length, rval.length);
-        sw.log();
-        return rval;
-    }
-    async fetchMetaForCacheFile(key, bucket = null) {
-        let rval = null;
-        try {
-            rval = await this.s3.send(new HeadObjectCommand({
-                Bucket: this.bucketVal(bucket),
-                Key: key,
-            }));
-        }
-        catch (err) {
-            if (err && err['statusCode'] == 404) {
-                Logger.info('Cache file %s %s not found returning null', this.bucketVal(bucket), key);
-                rval = null;
-            }
-            else {
-                Logger.error('Unrecognized error, rethrowing : %s', err, err);
-                throw err;
-            }
-        }
-        return rval;
-    }
-    async cacheFileAgeInSeconds(key, bucket = null) {
-        try {
-            const res = await this.fetchMetaForCacheFile(key, bucket);
-            if (res && res.LastModified) {
-                return Math.floor((new Date().getTime() - res.LastModified.getTime()) / 1000);
-            }
-            else {
-                Logger.warn('Cache file %s %s had no last modified returning null', this.bucketVal(bucket), key);
-                return null;
-            }
-        }
-        catch (err) {
-            if (err && err['statusCode'] == 404) {
-                Logger.warn('Cache file %s %s not found returning null', this.bucketVal(bucket), key);
-                return null;
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    async copyFile(srcKey, dstKey, srcBucket = null, dstBucket = null) {
-        const params = {
-            CopySource: '/' + this.bucketVal(srcBucket) + '/' + srcKey,
-            Bucket: this.bucketVal(dstBucket),
-            Key: dstKey,
-            MetadataDirective: 'COPY',
-        };
-        const rval = await this.s3.send(new CopyObjectCommand(params));
-        return rval;
-    }
-    async quietCopyFile(srcKey, dstKey, srcBucket = null, dstBucket = null) {
-        let rval = false;
-        try {
-            const tmp = await this.copyFile(srcKey, dstKey, srcBucket, dstBucket);
-            rval = true;
-        }
-        catch (err) {
-            Logger.silly('Failed to copy file in S3 : %s', err);
-        }
-        return rval;
-    }
-    async preSignedDownloadUrlForCacheFile(key, expirationSeconds = 3600, bucket = null) {
-        const getCommand = {
-            Bucket: this.bucketVal(bucket),
-            Key: key,
-        };
-        const link = await getSignedUrl(this.s3, new GetObjectCommand(getCommand), { expiresIn: expirationSeconds });
-        return link;
-    }
-    async directChildrenOfPrefix(prefix, expandFiles = false, bucket = null, maxToReturn = null) {
-        const returnValue = [];
-        const params = {
-            Bucket: this.bucketVal(bucket),
-            Prefix: prefix,
-            Delimiter: '/',
-        };
-        let response = null;
-        do {
-            response = await this.s3.send(new ListObjectsCommand(params));
-            const prefixLength = prefix.length;
-            if (response['CommonPrefixes']) {
-                response['CommonPrefixes'].forEach((cp) => {
-                    if (!maxToReturn || returnValue.length < maxToReturn) {
-                        const value = cp['Prefix'].substring(prefixLength);
-                        returnValue.push(value);
-                    }
-                });
-            }
-            if (response['Contents']) {
-                await Promise.all(response['Contents'].map(async (cp) => {
-                    if (!maxToReturn || returnValue.length < maxToReturn) {
-                        if (expandFiles) {
-                            const expanded = {
-                                link: await this.preSignedDownloadUrlForCacheFile(cp['Key'], 3600, bucket),
-                                name: cp['Key'].substring(prefixLength),
-                                size: cp['Size'],
-                            };
-                            returnValue.push(expanded);
-                        }
-                        else {
-                            returnValue.push(cp['Key'].substring(prefixLength));
-                        }
-                    }
-                }));
-            }
-            params.Marker = response.NextMarker;
-        } while (params.Marker && (!maxToReturn || returnValue.length < maxToReturn));
-        return returnValue;
-    }
-    async allSubFoldersOfPrefix(prefix, bucket = null) {
-        const returnValue = [prefix];
-        let idx = 0;
-        while (idx < returnValue.length) {
-            const next = returnValue[idx++];
-            Logger.debug('Pulling %s (%d remaining)', next, returnValue.length - idx);
-            const req = {
-                Bucket: this.bucketVal(bucket),
-                Prefix: next,
-                Delimiter: '/',
-            };
-            let resp = null;
-            do {
-                req.ContinuationToken = resp ? resp.NextContinuationToken : null;
-                resp = await this.s3.send(new ListObjectsCommand(req));
-                resp.CommonPrefixes.forEach((p) => {
-                    returnValue.push(p.Prefix);
-                });
-                Logger.debug('g:%j', resp);
-            } while (resp.NextContinuationToken);
-        }
-        return returnValue;
-    }
-    bucketVal(explicitBucket) {
-        const rval = explicitBucket ? explicitBucket : this.defaultBucket;
-        if (!rval) {
-            throw 'You must set either the default bucket or pass it explicitly';
-        }
-        return rval;
-    }
-}

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

@@ -1,97 +0,0 @@
-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/lib/logger/logger.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { StreamRatchet } from '@bitblit/ratchet-common/lib/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/lib/s3/s3-cache-to-local-disk-ratchet.js

@@ -1,105 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-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';
-export class S3CacheToLocalDiskRatchet {
-    s3;
-    tmpFolder;
-    cacheTimeoutSeconds;
-    static DEFAULT_CACHE_TIMEOUT_SEC = 7 * 24 * 3600;
-    currentlyLoading = new Map();
-    constructor(s3, tmpFolder, cacheTimeoutSeconds = S3CacheToLocalDiskRatchet.DEFAULT_CACHE_TIMEOUT_SEC) {
-        this.s3 = s3;
-        this.tmpFolder = tmpFolder;
-        this.cacheTimeoutSeconds = cacheTimeoutSeconds;
-        RequireRatchet.notNullOrUndefined(s3, 's3');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(tmpFolder));
-        RequireRatchet.true(fs.existsSync(tmpFolder), 'folder must exist : ' + tmpFolder);
-    }
-    async getFileString(key) {
-        const buf = await this.getFileBuffer(key);
-        return buf ? buf.toString() : null;
-    }
-    keyToLocalCachePath(key) {
-        const cachedHash = this.generateCacheHash(this.s3.getDefaultBucket() + '/' + key);
-        const rval = path.join(this.tmpFolder, cachedHash);
-        return rval;
-    }
-    removeCacheFileForKey(key) {
-        const localCachePath = this.keyToLocalCachePath(key);
-        Logger.info('Removing cache file for %s : %s', key, localCachePath);
-        if (fs.existsSync(localCachePath)) {
-            fs.unlinkSync(localCachePath);
-        }
-        else {
-            Logger.debug('Skipping delete for %s - does not exist', localCachePath);
-        }
-    }
-    async getFileBuffer(key) {
-        const localCachePath = this.keyToLocalCachePath(key);
-        let rval = null;
-        rval = this.getCacheFileAsBuffer(localCachePath);
-        if (!rval) {
-            Logger.info('No cache. Downloading File s3://%s/%s to %s', this.s3.getDefaultBucket(), key, localCachePath);
-            try {
-                let prom = this.currentlyLoading.get(key);
-                if (prom) {
-                    Logger.info('Already running - wait for that');
-                }
-                else {
-                    Logger.info('Not running - start');
-                    prom = this.updateLocalCacheFile(key, localCachePath);
-                    this.currentlyLoading.set(key, prom);
-                }
-                rval = await prom;
-                this.currentlyLoading.delete(key);
-            }
-            catch (err) {
-                Logger.warn('File %s/%s does not exist. Err code: %s', this.s3.getDefaultBucket(), key, err);
-            }
-        }
-        else {
-            Logger.info('Found cache file for s3://%s/%s. Local path %s', this.s3.getDefaultBucket(), key, localCachePath);
-        }
-        return rval;
-    }
-    async updateLocalCacheFile(key, localCachePath) {
-        const rval = await this.s3.fetchCacheFileAsBuffer(key);
-        if (rval && rval.length > 0) {
-            Logger.info('Saving %d bytes to disk for cache', rval.length);
-            fs.writeFileSync(localCachePath, rval);
-        }
-        return rval;
-    }
-    getCacheFileAsString(filePath) {
-        const buf = this.getCacheFileAsBuffer(filePath);
-        return buf ? buf.toString() : null;
-    }
-    getCacheFileAsBuffer(filePath) {
-        if (!fs.existsSync(filePath)) {
-            return null;
-        }
-        try {
-            const stats = fs.statSync(filePath);
-            const now = new Date().getTime();
-            const duration = (now - stats.ctimeMs) / 1000;
-            if (duration >= this.cacheTimeoutSeconds) {
-                return null;
-            }
-            else {
-                const rval = fs.readFileSync(filePath);
-                return rval;
-            }
-        }
-        catch (err) {
-            Logger.warn('Error getting s3 cache file %s', err);
-        }
-        return null;
-    }
-    generateCacheHash(hashVal) {
-        const rval = crypto.createHash('md5').update(hashVal).digest('hex');
-        return rval;
-    }
-}

package/lib/s3/s3-cache-to-local-dist-ratchet.spec.js

@@ -1,22 +0,0 @@
-import { S3CacheToLocalDiskRatchet } from './s3-cache-to-local-disk-ratchet.js';
-import { tmpdir } from 'os';
-import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
-import { jest } from '@jest/globals';
-let mockS3CR;
-describe('#S3CacheToLocalDiskRatchet', () => {
-    beforeEach(() => {
-        mockS3CR = JestRatchet.mock(jest.fn);
-    });
-    it('should download file and store in tmp', async () => {
-        mockS3CR.fetchCacheFileAsBuffer.mockResolvedValue(Buffer.from(JSON.stringify({ a: 'b' })));
-        const pth = 'test-path';
-        const svc = new S3CacheToLocalDiskRatchet(mockS3CR, tmpdir());
-        svc.removeCacheFileForKey(pth);
-        const proms = [];
-        for (let i = 0; i < 5; i++) {
-            proms.push(svc.getFileBuffer(pth));
-        }
-        const all = await Promise.all(proms);
-        expect(all.length).toEqual(5);
-    });
-});