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

package/dist/{types/batch → batch}/aws-batch-background-processor.d.ts

@@ -1,9 +1,5 @@
 import { SubmitJobCommandOutput } from '@aws-sdk/client-batch';
-import { AwsBatchRatchet } from './aws-batch-ratchet';
-/**
- * Class to simplify using AWS batch as a background processor
- * (Primarily used by Epsilon)
- */
+import { AwsBatchRatchet } from './aws-batch-ratchet.js';
 export declare class AwsBatchBackgroundProcessor {
     private batchRatchet;
     private validTaskNames?;

package/dist/{es/batch → batch}/aws-batch-background-processor.js

@@ -1,6 +1,11 @@
 import { DateTime } from 'luxon';
-import { ErrorRatchet, Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+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';
 export class AwsBatchBackgroundProcessor {
+    batchRatchet;
+    validTaskNames;
     constructor(batchRatchet, validTaskNames) {
         this.batchRatchet = batchRatchet;
         this.validTaskNames = validTaskNames;

package/dist/batch/aws-batch-background-processor.spec.js

@@ -0,0 +1,15 @@
+import { JestRatchet } from '@bitblit/ratchet-jest/dist/jest/jest-ratchet.js';
+import { AwsBatchBackgroundProcessor } from './aws-batch-background-processor.js';
+import { jest } from '@jest/globals';
+let mockBatchRatchet;
+describe('#AwsBatchBackgroundProcessor', () => {
+    beforeEach(() => {
+        mockBatchRatchet = JestRatchet.mock(jest.fn);
+    });
+    it('Should schedule background task', async () => {
+        mockBatchRatchet.scheduleJob.mockResolvedValue({ jobId: 'newID', jobName: 'name', $metadata: null });
+        const svc = new AwsBatchBackgroundProcessor(mockBatchRatchet, null);
+        const res = await svc.scheduleBackgroundTask('BACKGROUND_TASK_NAME', {}, {});
+        expect(res).not.toBeNull();
+    });
+});

package/dist/{types/batch → batch}/aws-batch-ratchet.d.ts

@@ -1,7 +1,4 @@
 import { BatchClient, JobStatus, JobSummary, SubmitJobCommandInput, SubmitJobCommandOutput } from '@aws-sdk/client-batch';
-/**
- * Ratchet for simplifying interacting with AWS Batch
- */
 export declare class AwsBatchRatchet {
     private _batchClient;
     private _defaultQueueName?;

package/dist/{es/batch → batch}/aws-batch-ratchet.js

@@ -1,6 +1,10 @@
 import { ListJobsCommand, SubmitJobCommand, } from '@aws-sdk/client-batch';
-import { Logger, RequireRatchet } 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 AwsBatchRatchet {
+    _batchClient;
+    _defaultQueueName;
+    _defaultJobDefinition;
     constructor(_batchClient, _defaultQueueName, _defaultJobDefinition) {
         this._batchClient = _batchClient;
         this._defaultQueueName = _defaultQueueName;

package/dist/batch/aws-batch-ratchet.spec.js

@@ -0,0 +1,33 @@
+import { AwsBatchRatchet } from './aws-batch-ratchet.js';
+import { BatchClient, JobStatus, ListJobsCommand, SubmitJobCommand } from '@aws-sdk/client-batch';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockBatch;
+describe('#AwsBatchService', () => {
+    mockBatch = mockClient(BatchClient);
+    beforeEach(() => {
+        mockBatch.reset();
+    });
+    it('Should schedule batch job', async () => {
+        const svc = new AwsBatchRatchet(mockBatch);
+        mockBatch.on(SubmitJobCommand).resolves({ jobName: 'b' });
+        const res = await svc.scheduleJob({
+            jobName: 'testName',
+            jobDefinition: 'testDefinition',
+            jobQueue: 'testQueue',
+        });
+        expect(res).not.toBeNull();
+    });
+    it('Should list jobs', async () => {
+        const svc = new AwsBatchRatchet(mockBatch);
+        mockBatch.on(ListJobsCommand).resolves([{}]);
+        const res = await svc.listJobs('testQueue');
+        expect(res).not.toBeNull();
+        expect(res.length).toEqual(1);
+    });
+    it('Should count jobs in state', async () => {
+        const svc = new AwsBatchRatchet(mockBatch);
+        mockBatch.on(ListJobsCommand).resolves([{}]);
+        const res = await svc.jobCountInState(JobStatus.RUNNABLE, 'testQueue');
+        expect(res).toEqual(1);
+    });
+});

package/dist/{types/build → build}/ratchet-aws-info.d.ts

@@ -1,4 +1,4 @@
-import { BuildInformation } from '@bitblit/ratchet-common';
+import { BuildInformation } from '@bitblit/ratchet-common/dist/build/build-information.js';
 export declare class RatchetAwsInfo {
     private constructor();
     static buildInformation(): BuildInformation;

package/dist/{types/cache → cache}/dynamo-db-storage-provider.d.ts

@@ -1,6 +1,6 @@
-import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
-import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
-import { DynamoRatchet } from '../dynamodb/dynamo-ratchet';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider.js';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
 export declare class DynamoDbStorageProvider implements SimpleCacheStorageProvider {
     private dynamo;
     private opts;

package/dist/{es/cache → cache}/dynamo-db-storage-provider.js

@@ -1,5 +1,7 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
 export class DynamoDbStorageProvider {
+    dynamo;
+    opts;
     constructor(dynamo, opts) {
         this.dynamo = dynamo;
         this.opts = opts;

package/dist/{types/cache → cache}/s3-storage-provider.d.ts

@@ -1,6 +1,6 @@
-import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
-import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
 export declare class S3StorageProvider implements SimpleCacheStorageProvider {
     private s3CacheRatchet;
     private prefix;

package/dist/{es/cache → cache}/s3-storage-provider.js

@@ -1,5 +1,8 @@
-import { RequireRatchet, 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 S3StorageProvider {
+    s3CacheRatchet;
+    prefix;
     constructor(s3CacheRatchet, prefix) {
         this.s3CacheRatchet = s3CacheRatchet;
         this.prefix = prefix;

package/dist/{types/cache → cache}/simple-cache-storage-provider.d.ts

@@ -1,4 +1,4 @@
-import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
 export interface SimpleCacheStorageProvider {
     readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>>;
     storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean>;

package/dist/{types/cache → cache}/simple-cache.d.ts

@@ -1,6 +1,6 @@
-import { SimpleCacheStorageProvider } from './simple-cache-storage-provider';
-import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper';
-import { SimpleCacheReadOptions } from './simple-cache-read-options';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider.js';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { SimpleCacheReadOptions } from './simple-cache-read-options.js';
 export declare class SimpleCache {
     private provider;
     private defaultTimeToLiveMS;

package/dist/{es/cache → cache}/simple-cache.js

@@ -1,6 +1,8 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class SimpleCache {
-    constructor(provider, defaultTimeToLiveMS = 1000 * 60) {
+    provider;
+    defaultTimeToLiveMS;
+    constructor(provider, defaultTimeToLiveMS = 1_000 * 60) {
         this.provider = provider;
         this.defaultTimeToLiveMS = defaultTimeToLiveMS;
     }

package/dist/cache/simple-cache.spec.js

@@ -0,0 +1,67 @@
+import { S3StorageProvider } from './s3-storage-provider.js';
+import { SimpleCache } from './simple-cache.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
+import { DynamoDbStorageProvider } from './dynamo-db-storage-provider.js';
+import { S3Client } from '@aws-sdk/client-s3';
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+describe('#simpleCache', function () {
+    xit('should read/write/delete with an S3 handler', async () => {
+        const s3 = new S3Client({ region: 'us-east-1' });
+        const cache = new S3CacheRatchet(s3, 'test-bucket');
+        const s3StorageProvider = new S3StorageProvider(cache, 'test-cache');
+        const simpleCache = new SimpleCache(s3StorageProvider, 2000000);
+        await simpleCache.removeFromCache('test1');
+        const test1a = await simpleCache.fetchWrapper('test1', () => Promise.resolve({ x: 1 }));
+        expect(test1a).not.toBeNull();
+        expect(test1a.generated).toBeTruthy();
+        expect(test1a.value).not.toBeNull();
+        expect(test1a.value['x']).toEqual(1);
+        const test1b = await simpleCache.fetchWrapper('test1', () => Promise.resolve({ x: 1 }));
+        expect(test1b).not.toBeNull();
+        expect(test1b.generated).toBeFalsy();
+        expect(test1b.value).not.toBeNull();
+        expect(test1b.value['x']).toEqual(1);
+        await simpleCache.removeFromCache('test1');
+    }, 60_000);
+    xit('should read/write/delete with an dynamo handler', async () => {
+        const dr = new DynamoRatchet(DynamoDBDocument.from(new DynamoDBClient({ region: 'us-east-1' })));
+        const opts = DynamoDbStorageProvider.createDefaultOptions();
+        opts.tableName = 'test-table';
+        opts.useRangeKeys = false;
+        opts.hashKeyName = 'cacheUid';
+        opts.dynamoExpiresColumnName = 'expiresEpochSeconds';
+        const ddbStorage = new DynamoDbStorageProvider(dr, opts);
+        const simpleCache = new SimpleCache(ddbStorage, 2000000);
+        await simpleCache.removeFromCache('test1');
+        const test1a = await simpleCache.fetchWrapper('test1', () => Promise.resolve({ x: 1 }));
+        expect(test1a).not.toBeNull();
+        expect(test1a.generated).toBeTruthy();
+        expect(test1a.value).not.toBeNull();
+        expect(test1a.value['x']).toEqual(1);
+        const test1b = await simpleCache.fetchWrapper('test1', () => Promise.resolve({ x: 1 }));
+        expect(test1b).not.toBeNull();
+        expect(test1b.generated).toBeFalsy();
+        expect(test1b.value).not.toBeNull();
+        expect(test1b.value['x']).toEqual(1);
+        await simpleCache.removeFromCache('test1');
+    }, 60_000);
+    xit('should write a bunch', async () => {
+        const dr = new DynamoRatchet(DynamoDBDocument.from(new DynamoDBClient({ region: 'us-east-1' })));
+        const opts = DynamoDbStorageProvider.createDefaultOptions();
+        opts.tableName = 'test-table';
+        opts.useRangeKeys = false;
+        opts.hashKeyName = 'cacheUid';
+        opts.dynamoExpiresColumnName = 'expiresEpochSeconds';
+        const ddbStorage = new DynamoDbStorageProvider(dr, opts);
+        const simpleCache = new SimpleCache(ddbStorage, 1000);
+        for (let i = 0; i < 10; i++) {
+            const tests = await simpleCache.fetchWrapper('test' + i, () => Promise.resolve({ x: i }));
+        }
+        const all = await simpleCache.readAll();
+        expect(all).not.toBeNull();
+        expect(all.length).toBeGreaterThan(9);
+        await simpleCache.clearCache();
+    }, 60_000);
+});

package/dist/{es/cloudwatch → cloudwatch}/cloud-watch-log-group-ratchet.js

@@ -1,7 +1,9 @@
 import { CloudWatchLogsClient, DescribeLogStreamsCommand, FilterLogEventsCommand, } from '@aws-sdk/client-cloudwatch-logs';
-import { Logger } from '@bitblit/ratchet-common';
-import { StopWatch } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StopWatch } from '@bitblit/ratchet-common/dist/lang/stop-watch.js';
 export class CloudWatchLogGroupRatchet {
+    logGroup;
+    awsCWLogs;
     constructor(logGroup, awsCWLogs = new CloudWatchLogsClient({ region: 'us-east-1' })) {
         this.logGroup = logGroup;
         this.awsCWLogs = awsCWLogs;

package/dist/cloudwatch/cloud-watch-log-group-ratchet.spec.js

@@ -0,0 +1,19 @@
+import { CloudWatchLogsClient, DescribeLogStreamsCommand } from '@aws-sdk/client-cloudwatch-logs';
+import { CloudWatchLogGroupRatchet } from './cloud-watch-log-group-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockCW;
+describe('#CloudWatchLogGroupRatchet', function () {
+    mockCW = mockClient(CloudWatchLogsClient);
+    beforeEach(() => {
+        mockCW.reset();
+    });
+    it('should read log stream names', async () => {
+        mockCW.on(DescribeLogStreamsCommand).resolves({
+            logStreams: [{ logStreamName: '1' }, { logStreamName: '2' }],
+        });
+        const cw = new CloudWatchLogGroupRatchet('testGroup', mockCW);
+        const res = await cw.readLogStreamNames();
+        expect(res).toBeTruthy();
+        expect(res.length).toEqual(2);
+    });
+});

package/dist/{es/cloudwatch → cloudwatch}/cloud-watch-logs-ratchet.js

@@ -1,9 +1,11 @@
 import { CloudWatchLogsClient, DeleteLogGroupCommand, DeleteLogStreamCommand, DescribeLogGroupsCommand, DescribeLogStreamsCommand, GetQueryResultsCommand, StartQueryCommand, StopQueryCommand, } from '@aws-sdk/client-cloudwatch-logs';
-import { Logger } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } 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 { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
 export class CloudWatchLogsRatchet {
+    static MAX_DELETE_RETRIES = 5;
+    cwLogs;
     constructor(cloudwatchLogs = null) {
         this.cwLogs = cloudwatchLogs ? cloudwatchLogs : new CloudWatchLogsClient({ region: 'us-east-1' });
     }
@@ -166,4 +168,3 @@ export class CloudWatchLogsRatchet {
         return rval;
     }
 }
-CloudWatchLogsRatchet.MAX_DELETE_RETRIES = 5;

package/dist/cloudwatch/cloud-watch-logs-ratchet.spec.js

@@ -0,0 +1,84 @@
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { CloudWatchLogsRatchet } from './cloud-watch-logs-ratchet.js';
+import { CloudWatchLogsClient, DeleteLogGroupCommand, DeleteLogStreamCommand, DescribeLogGroupsCommand, DescribeLogStreamsCommand, GetQueryResultsCommand, StartQueryCommand, } from '@aws-sdk/client-cloudwatch-logs';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockCW;
+describe('#cloudWatchLogsRatchet', function () {
+    mockCW = mockClient(CloudWatchLogsClient);
+    beforeEach(() => {
+        mockCW.reset();
+    });
+    it('should find the stream with the oldest timestamp in a group', async () => {
+        mockCW.on(DescribeLogStreamsCommand).resolves({
+            logStreams: [
+                { logStreamName: '1', firstEventTimestamp: 100 },
+                { logStreamName: '2', firstEventTimestamp: 200 },
+            ],
+        });
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const res = await cw.findStreamWithOldestEventInGroup('test');
+        expect(res).toBeTruthy();
+        expect(res.logStreamName).toEqual('1');
+    });
+    it('should find the oldest timestamp in group', async () => {
+        mockCW.on(DescribeLogStreamsCommand).resolves({
+            logStreams: [
+                { logStreamName: '1', firstEventTimestamp: 100 },
+                { logStreamName: '2', firstEventTimestamp: 200 },
+            ],
+        });
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const res = await cw.findOldestEventTimestampInGroup('test');
+        expect(res).toEqual(100);
+    });
+    it('should remove log groups', async () => {
+        mockCW.on(DeleteLogGroupCommand).resolves(null);
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const res = await cw.removeLogGroups([{ logGroupName: '1' }, { logGroupName: '2' }]);
+        expect(res.length).toEqual(2);
+    });
+    it('should remove log groups with prefix', async () => {
+        mockCW.on(DescribeLogGroupsCommand).resolves({
+            logGroups: [{ logGroupName: 'pre1' }, { logGroupName: 'pre2' }],
+        });
+        mockCW.on(DeleteLogGroupCommand).resolves(null);
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const res = await cw.removeLogGroupsWithPrefix('pre');
+        expect(res.length).toEqual(2);
+    });
+    it('should remove empty or old log streams', async () => {
+        mockCW.on(DescribeLogStreamsCommand).resolves({
+            logStreams: [{ logStreamName: '1' }, { logStreamName: '2' }],
+        });
+        mockCW.on(DeleteLogStreamCommand).resolves(null);
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const res = await cw.removeEmptyOrOldLogStreams('test', 1000);
+        expect(res).toBeTruthy();
+        expect(res.length).toEqual(2);
+    });
+    it('should find all matching groups', async () => {
+        mockCW.on(DescribeLogGroupsCommand).resolves({ logGroups: [{ logGroupName: '1' }, { logGroupName: '2' }] });
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const prefix = '/';
+        const res = await cw.findLogGroups(prefix);
+        expect(res).toBeTruthy();
+        expect(res.length).toEqual(2);
+    });
+    it('should execute an insights query', async () => {
+        mockCW.on(StartQueryCommand).resolves({ queryId: 'test' });
+        mockCW.on(GetQueryResultsCommand).resolves({});
+        const cw = new CloudWatchLogsRatchet(mockCW);
+        const logGroups = ['/someGroup'];
+        const now = Math.floor(new Date().getTime() / 1000);
+        const req = {
+            endTime: now,
+            limit: 200,
+            logGroupNames: logGroups,
+            queryString: 'fields @timestamp, @message | sort @timestamp desc',
+            startTime: now - 60 * 60 * 24,
+        };
+        const res = await cw.fullyExecuteInsightsQuery(req);
+        expect(res).toBeTruthy();
+        Logger.info('Got : %j', res);
+    });
+});

package/dist/{types/cloudwatch → cloudwatch}/cloud-watch-metrics-ratchet.d.ts

@@ -1,7 +1,7 @@
 import { CloudWatchClient } from '@aws-sdk/client-cloudwatch';
-import { KeyValue } from '@bitblit/ratchet-common';
-import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit';
-import { CloudWatchMetricsMinuteLevelDynamoCountRequest } from '../model/cloud-watch-metrics-minute-level-dynamo-count-request';
+import { KeyValue } from '@bitblit/ratchet-common/dist/lang/key-value.js';
+import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit.js';
+import { CloudWatchMetricsMinuteLevelDynamoCountRequest } from '../model/cloud-watch-metrics-minute-level-dynamo-count-request.js';
 export declare class CloudWatchMetricsRatchet {
     private cw;
     constructor(cloudWatch?: CloudWatchClient);

package/dist/{es/cloudwatch → cloudwatch}/cloud-watch-metrics-ratchet.js

@@ -1,8 +1,9 @@
 import { CloudWatchClient, PutMetricDataCommand } from '@aws-sdk/client-cloudwatch';
-import { Logger } from '@bitblit/ratchet-common';
-import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit.js';
 import { DateTime } from 'luxon';
 export class CloudWatchMetricsRatchet {
+    cw;
     constructor(cloudWatch = null) {
         this.cw = cloudWatch ? cloudWatch : new CloudWatchClient({ region: 'us-east-1', apiVersion: '2010-08-01' });
     }

package/dist/cloudwatch/cloud-watch-metrics-ratchet.spec.js

@@ -0,0 +1,23 @@
+import { CloudWatchMetricsRatchet } from './cloud-watch-metrics-ratchet.js';
+import { CloudWatchMetricsUnit } from '../model/cloud-watch-metrics-unit.js';
+import { CloudWatchClient, PutMetricDataCommand } from '@aws-sdk/client-cloudwatch';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockCW;
+describe('#cloudWatchMetricsRatchet', function () {
+    mockCW = mockClient(CloudWatchClient);
+    beforeEach(() => {
+        mockCW.reset();
+        mockCW.reset();
+    });
+    it('should log a cloudwatch metric', async () => {
+        mockCW.on(PutMetricDataCommand).resolves({ ok: true });
+        const cw = new CloudWatchMetricsRatchet(mockCW);
+        const dims = [
+            { key: 'server', value: 'prod' },
+            { key: 'stage', value: 'v0' },
+            { key: 'version', value: '20190529-01' },
+        ];
+        const res = await cw.writeSingleMetric('Ratchet/TestMetric01', 'MyMetric01', dims, CloudWatchMetricsUnit.Count, 2, new Date(), false);
+        expect(res).toBeTruthy();
+    });
+});

package/dist/{types/daemon → daemon}/daemon-like.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
-import { DaemonProcessState } from './daemon-process-state';
-import { DaemonProcessCreateOptions } from './daemon-process-create-options';
+/// <reference types="node" resolution-mode="require"/>
+import { DaemonProcessState } from './daemon-process-state.js';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options.js';
 export interface DaemonLike {
     get defaultGroup(): string;
     keyToPublicToken(key: string, expirationSeconds: number): Promise<string>;

package/dist/{types/daemon → daemon}/daemon-process-state-public-token.d.ts

@@ -1,4 +1,4 @@
-import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtTokenBase } from '@bitblit/ratchet-common/dist/jwt/jwt-token-base.js';
 export interface DaemonProcessStatePublicToken extends JwtTokenBase {
     daemonKey: string;
 }

package/dist/{types/daemon → daemon}/daemon-util.d.ts

@@ -1,15 +1,9 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { DaemonProcessState } from './daemon-process-state';
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-import { DaemonProcessCreateOptions } from './daemon-process-create-options';
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { DaemonProcessState } from './daemon-process-state.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options.js';
 import { Readable } from 'stream';
-/**
- * Internal utilities which are here for the USE OF THE DAEMON OBJECT ONLY - if you are trying to use this
- * class outside of Ratchet, you are doing it wrong.  Instantiate a Daemon object and use that instead.
- *
- * The details of storage and retrieval of a DaemonProcessState is meant to be transparent to the user
- */
 export declare class DaemonUtil {
     static DEFAULT_CONTENT: Buffer;
     static DAEMON_METADATA_KEY: string;

package/dist/{es/daemon → daemon}/daemon-util.js

@@ -1,7 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 import { PutObjectCommand, } from '@aws-sdk/client-s3';
 import { Upload } from '@aws-sdk/lib-storage';
 export class DaemonUtil {
+    static DEFAULT_CONTENT = Buffer.from('DAEMON_PLACEHOLDER');
+    static DAEMON_METADATA_KEY = 'daemon_meta';
     static async start(cache, id, s3Key, options) {
         try {
             options.meta = options.meta || {};
@@ -144,5 +146,3 @@ export class DaemonUtil {
         }
     }
 }
-DaemonUtil.DEFAULT_CONTENT = Buffer.from('DAEMON_PLACEHOLDER');
-DaemonUtil.DAEMON_METADATA_KEY = 'daemon_meta';

package/dist/daemon/daemon-util.spec.d.ts

@@ -0,0 +1,4 @@
+export interface TestItem {
+    a: number;
+    b: string;
+}

package/dist/daemon/daemon-util.spec.js

@@ -0,0 +1,79 @@
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { DaemonUtil } from './daemon-util.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 fs from 'fs';
+import { JestRatchet } from '@bitblit/ratchet-jest/dist/jest/jest-ratchet.js';
+import { Subject } from 'rxjs';
+import { PassThrough } from 'stream';
+import { CsvRatchet } from '@bitblit/ratchet-node-only/dist/csv/csv-ratchet.js';
+import { S3Client } from '@aws-sdk/client-s3';
+import { jest } from '@jest/globals';
+let mockS3CR;
+describe('#DaemonUtil', function () {
+    beforeEach(() => {
+        mockS3CR = JestRatchet.mock(jest.fn);
+    });
+    it('should test the daemon util', async () => {
+        mockS3CR.getDefaultBucket.mockReturnValueOnce('TEST-BUCKET');
+        mockS3CR.fetchMetaForCacheFile.mockResolvedValue({
+            Metadata: { daemon_meta: '{"id":"testid", "completedEpochMS":123456}' },
+            $metadata: null,
+        });
+        mockS3CR.preSignedDownloadUrlForCacheFile.mockResolvedValue('https://test-link');
+        const t1 = await DaemonUtil.stat(mockS3CR, 'test1.csv');
+        Logger.info('Got : %j', t1);
+        expect(t1).not.toBeNull();
+        expect(t1.link).not.toBeNull();
+    });
+    xit('should test the daemon util streaming', async () => {
+        const s3 = new S3Client({ region: 'us-east-1' });
+        const cache = new S3CacheRatchet(s3, 'test-bucket');
+        const key = 's3-cache-ratchet.spec.ts';
+        const newDaemonOptions = {
+            title: 'test',
+            contentType: 'text/plain',
+            group: 'NA',
+            meta: {},
+            targetFileName: 's3-cache-ratchet.spec.ts',
+        };
+        const t2 = await DaemonUtil.start(cache, key, 's3-cache-ratchet.spec.ts', newDaemonOptions);
+        const t1 = await DaemonUtil.stat(cache, key);
+        Logger.info('Got : %j', t1);
+        const stream = fs.createReadStream('test/aws/s3-cache-ratchet.spec.ts');
+        const result = await DaemonUtil.streamDataAndFinish(cache, key, stream);
+        expect(result).toBeTruthy();
+        Logger.info('Got objects : %j', result);
+    });
+    xit('should stream objects to a csv', async () => {
+        Logger.setLevel(LoggerLevelName.debug);
+        const sub = new Subject();
+        const out = new PassThrough();
+        const s3 = new S3Client({ region: 'us-east-1' });
+        const cache = new S3CacheRatchet(s3, 'test-bucket');
+        const key = 'test.csv';
+        const newDaemonOptions = {
+            title: 'test',
+            contentType: 'text/csv',
+            group: 'NA',
+            meta: {},
+            targetFileName: 'test.csv',
+        };
+        const t2 = await DaemonUtil.start(cache, key, key, newDaemonOptions);
+        const dProm = DaemonUtil.streamDataAndFinish(cache, key, out);
+        const prom = CsvRatchet.streamObjectsToCsv(sub, out);
+        for (let i = 1; i < 6; i++) {
+            Logger.debug('Proc : %d', i);
+            sub.next({ a: i, b: 'test ' + i + ' ,,' });
+            await PromiseRatchet.wait(10);
+        }
+        sub.complete();
+        Logger.debug('Waiting on write');
+        const result = await prom;
+        Logger.debug('Write complete');
+        const val = await dProm;
+        expect(result).toEqual(5);
+        Logger.debug('Have res : %d and val : \n%j', result, val);
+    });
+});

package/dist/{types/daemon → daemon}/daemon.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="node" />
-import { DaemonProcessState } from './daemon-process-state';
-import { DaemonProcessCreateOptions } from './daemon-process-create-options';
-import { DaemonLike } from './daemon-like';
-import { JwtRatchetLike } from '@bitblit/ratchet-common';
+/// <reference types="node" resolution-mode="require"/>
+import { JwtRatchetLike } from '@bitblit/ratchet-common/dist/jwt/jwt-ratchet-like.js';
+import { DaemonProcessState } from './daemon-process-state.js';
+import { DaemonProcessCreateOptions } from './daemon-process-create-options.js';
+import { DaemonLike } from './daemon-like.js';
 import { S3Client } from '@aws-sdk/client-s3';
 export declare class Daemon implements DaemonLike {
     private s3;

package/dist/{es/daemon → daemon}/daemon.js

@@ -1,9 +1,16 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { DaemonUtil } from './daemon-util';
-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';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { DaemonUtil } from './daemon-util.js';
 export class Daemon {
+    s3;
+    bucket;
+    prefix;
+    _defaultGroup;
+    jwtRatchet;
+    static DEFAULT_DEFAULT_GROUP = 'DEFAULT';
+    cache;
     constructor(s3, bucket, prefix = '', _defaultGroup = Daemon.DEFAULT_DEFAULT_GROUP, jwtRatchet) {
         this.s3 = s3;
         this.bucket = bucket;
@@ -119,4 +126,3 @@ export class Daemon {
         return DaemonUtil.finalize(this.cache, this.keyToPath(id), contents);
     }
 }
-Daemon.DEFAULT_DEFAULT_GROUP = 'DEFAULT';

package/dist/{types/dao → dao}/prototype-dao-provider.d.ts

@@ -1,4 +1,4 @@
-import { PrototypeDaoDb } from './prototype-dao-db';
+import { PrototypeDaoDb } from './prototype-dao-db.js';
 export interface PrototypeDaoProvider<T> {
     storeDatabase(db: PrototypeDaoDb<T>): Promise<boolean>;
     loadDatabase(): Promise<PrototypeDaoDb<T>>;