@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/cjs/background/manager/abstract-background-manager.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBackgroundManager = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const luxon_1 = require("luxon");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const context_util_1 = require("../../util/context-util");
+class AbstractBackgroundManager {
+    createEntry(type, data) {
+        const rval = {
+            type: type,
+            data: data,
+        };
+        return rval;
+    }
+    wrapEntryForInternal(entry, overrideTraceId, overrideTraceDepth) {
+        const rval = Object.assign({}, entry, {
+            createdEpochMS: new Date().getTime(),
+            guid: AbstractBackgroundManager.generateBackgroundGuid(),
+            traceId: overrideTraceId || context_util_1.ContextUtil.currentTraceId(),
+            traceDepth: overrideTraceDepth || context_util_1.ContextUtil.currentTraceDepth() + 1,
+        });
+        return rval;
+    }
+    async addEntryToQueueByParts(type, data, fireStartMessage) {
+        let rval = null;
+        const entry = this.createEntry(type, data);
+        if (entry) {
+            rval = await this.addEntryToQueue(entry, fireStartMessage);
+        }
+        return rval;
+    }
+    async addEntriesToQueue(entries, fireStartMessage) {
+        const rval = [];
+        for (let i = 0; i < entries.length; i++) {
+            try {
+                const tmp = await this.addEntryToQueue(entries[i], false);
+                rval.push(tmp);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Error processing %j : %s', entries[i], err);
+                rval.push(err['message']);
+            }
+            if (fireStartMessage) {
+                const fireResult = await this.fireStartProcessingRequest();
+                ratchet_common_1.Logger.silly('FireResult : %s', fireResult);
+            }
+        }
+        return rval;
+    }
+    async fireImmediateProcessRequestByParts(type, data) {
+        let rval = null;
+        const entry = this.createEntry(type, data);
+        if (entry) {
+            rval = await this.fireImmediateProcessRequest(entry);
+        }
+        return rval;
+    }
+    static generateBackgroundGuid(targetEpochMS = new Date().getTime()) {
+        const dt = luxon_1.DateTime.fromMillis(targetEpochMS);
+        return dt.toFormat('yyyy-MM-dd-HH-mm-ss-') + ratchet_common_2.StringRatchet.createType4Guid();
+    }
+    static backgroundGuidToPath(prefix, guid) {
+        let path = ratchet_common_2.StringRatchet.trimToEmpty(prefix);
+        if (path.length && !path.endsWith('/')) {
+            path += '/';
+        }
+        path += guid.substring(0, 4) + '/' + guid.substring(5, 7) + '/' + guid.substring(8, 10) + '/';
+        path += guid + '.json';
+        return path;
+    }
+    static pathToBackgroundGuid(prefix, path) {
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(path, 'path');
+        let start = 0;
+        if (!path.endsWith('.json')) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot extract guid, does not end with .json : %s : %s', path, prefix);
+        }
+        if (ratchet_common_2.StringRatchet.trimToNull(prefix)) {
+            if (!path.startsWith(prefix)) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot extract guid, does not start with prefix : %s : %s', path, prefix);
+            }
+            start = prefix.length;
+            if (!prefix.endsWith('/')) {
+                start++;
+            }
+        }
+        start += 11;
+        return path.substring(start, path.length - 5);
+    }
+}
+exports.AbstractBackgroundManager = AbstractBackgroundManager;

package/dist/cjs/background/manager/aws-sqs-sns-background-manager.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsSqsSnsBackgroundManager = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const epsilon_constants_1 = require("../../epsilon-constants");
+const abstract_background_manager_1 = require("./abstract-background-manager");
+const background_validator_1 = require("../background-validator");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const client_sns_1 = require("@aws-sdk/client-sns");
+class AwsSqsSnsBackgroundManager extends abstract_background_manager_1.AbstractBackgroundManager {
+    constructor(_awsConfig, _sqs, _sns) {
+        super();
+        this._awsConfig = _awsConfig;
+        this._sqs = _sqs;
+        this._sns = _sns;
+        const cfgErrors = background_validator_1.BackgroundValidator.validateAwsConfig(_awsConfig);
+        if (cfgErrors.length) {
+            ratchet_common_2.ErrorRatchet.throwFormattedErr('Cannot start - invalid AWS config : %j', cfgErrors);
+        }
+    }
+    get backgroundManagerName() {
+        return 'AwsSqsSnsBackgroundManager';
+    }
+    get awsConfig() {
+        return this._awsConfig;
+    }
+    get sqs() {
+        return this._sqs;
+    }
+    get sns() {
+        return this._sns;
+    }
+    async addEntryToQueue(entry, fireStartMessage) {
+        try {
+            const wrapped = this.wrapEntryForInternal(entry);
+            const rval = wrapped.guid;
+            const params = {
+                DelaySeconds: 0,
+                MessageBody: JSON.stringify(wrapped),
+                MessageGroupId: entry.type,
+                QueueUrl: this.awsConfig.queueUrl,
+            };
+            ratchet_common_1.Logger.info('Add entry to queue (remote) : %j : Start : %s', params, fireStartMessage);
+            const result = await this.sqs.send(new client_sqs_1.SendMessageCommand(params));
+            if (fireStartMessage) {
+                const fireResult = await this.fireStartProcessingRequest();
+                ratchet_common_1.Logger.silly('FireResult : %s', fireResult);
+            }
+            ratchet_common_1.Logger.info('Background process %s using message id %s', rval, result.MessageId);
+            return rval;
+        }
+        catch (error) {
+            ratchet_common_1.Logger.error('Error inserting background entry into SQS queue : %j', error);
+            throw new Error('Error inserting background entry into SQS queue : ' + error['code'] + ' : ' + error['name']);
+        }
+    }
+    async fireImmediateProcessRequest(entry) {
+        let rval = null;
+        const wrapped = this.wrapEntryForInternal(entry);
+        rval = wrapped.guid;
+        try {
+            ratchet_common_1.Logger.info('Fire immediately (remote) : %j ', entry);
+            const toWrite = {
+                type: epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG,
+                backgroundEntry: wrapped,
+            };
+            const msg = JSON.stringify(toWrite);
+            const snsId = await this.writeMessageToSnsTopic(msg);
+            ratchet_common_1.Logger.debug('Background guid %s Wrote message : %s to SNS : %s', rval, msg, snsId);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Failed to fireImmediateProcessRequest : %s', err, err);
+        }
+        return rval;
+    }
+    async fireStartProcessingRequest() {
+        let rval = null;
+        try {
+            ratchet_common_1.Logger.info('Fire start processing request (remote)');
+            rval = await this.writeMessageToSnsTopic(epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_START_MARKER);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Failed to fireStartProcessingRequest : %s', err, err);
+        }
+        return rval;
+    }
+    async fetchApproximateNumberOfQueueEntries() {
+        let rval = null;
+        const all = await this.fetchCurrentQueueAttributes();
+        rval = ratchet_common_1.NumberRatchet.safeNumber(all.Attributes['ApproximateNumberOfMessages']);
+        return rval;
+    }
+    async fetchCurrentQueueAttributes() {
+        let rval = null;
+        const req = {
+            AttributeNames: ['All'],
+            QueueUrl: this.awsConfig.queueUrl,
+        };
+        rval = await this.sqs.send(new client_sqs_1.GetQueueAttributesCommand(req));
+        return rval;
+    }
+    async writeMessageToSnsTopic(message) {
+        let rval = null;
+        const params = {
+            Message: message,
+            TopicArn: this.awsConfig.notificationArn,
+        };
+        ratchet_common_1.Logger.debug('Writing message to SNS topic : j', params);
+        const result = await this.sns.send(new client_sns_1.PublishCommand(params));
+        rval = result.MessageId;
+        return rval;
+    }
+    async takeEntryFromBackgroundQueue() {
+        const rval = [];
+        const params = {
+            MaxNumberOfMessages: 1,
+            QueueUrl: this.awsConfig.queueUrl,
+            VisibilityTimeout: 300,
+            WaitTimeSeconds: 0,
+        };
+        const message = await this.sqs.send(new client_sqs_1.ReceiveMessageCommand(params));
+        if (message && message.Messages && message.Messages.length > 0) {
+            for (let i = 0; i < message.Messages.length; i++) {
+                const m = message.Messages[i];
+                try {
+                    const parsedBody = JSON.parse(m.Body);
+                    if (!parsedBody.type) {
+                        ratchet_common_1.Logger.warn('Dropping invalid background entry : %j', parsedBody);
+                    }
+                    else {
+                        rval.push(parsedBody);
+                    }
+                    ratchet_common_1.Logger.debug('Removing message from queue');
+                    const delParams = {
+                        QueueUrl: this.awsConfig.queueUrl,
+                        ReceiptHandle: m.ReceiptHandle,
+                    };
+                    const delResult = await this.sqs.send(new client_sqs_1.DeleteMessageCommand(delParams));
+                    ratchet_common_1.Logger.silly('Delete result : %j', delResult);
+                }
+                catch (err) {
+                    ratchet_common_1.Logger.warn('Error parsing message, dropping : %j', m);
+                }
+            }
+        }
+        else {
+            ratchet_common_1.Logger.debug('No messages found (likely end of recursion)');
+        }
+        return rval;
+    }
+}
+exports.AwsSqsSnsBackgroundManager = AwsSqsSnsBackgroundManager;

package/dist/cjs/background/manager/background-manager-like.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/background/manager/single-thread-local-background-manager.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleThreadLocalBackgroundManager = void 0;
+const rxjs_1 = require("rxjs");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const abstract_background_manager_1 = require("./abstract-background-manager");
+class SingleThreadLocalBackgroundManager extends abstract_background_manager_1.AbstractBackgroundManager {
+    get backgroundManagerName() {
+        return 'SingleThreadLocalBackgroundManager';
+    }
+    constructor() {
+        super();
+        this._localBus = new rxjs_1.Subject();
+    }
+    immediateProcessQueue() {
+        return this._localBus;
+    }
+    async addEntryToQueue(entry, fireStartMessage) {
+        const wrapped = this.wrapEntryForInternal(entry);
+        const rval = wrapped.guid;
+        ratchet_common_1.Logger.info('Add entry to queue (local) : %j : Start : %s', entry, fireStartMessage);
+        this._localBus.next(wrapped);
+        return rval;
+    }
+    async fireImmediateProcessRequest(entry) {
+        let rval = null;
+        const wrapped = this.wrapEntryForInternal(entry);
+        rval = wrapped.guid;
+        ratchet_common_1.Logger.info('Fire immediately (local) : %j ', entry);
+        this._localBus.next(wrapped);
+        return rval;
+    }
+    async fireStartProcessingRequest() {
+        let rval = null;
+        ratchet_common_1.Logger.info('Fire start processing request (local, ignored)');
+        rval = 'NO-OP';
+        return rval;
+    }
+    async fetchApproximateNumberOfQueueEntries() {
+        let rval = null;
+        rval = 0;
+        return rval;
+    }
+    async takeEntryFromBackgroundQueue() {
+        ratchet_common_1.Logger.info('Called takeEntryFromBackgroundQueue on SingleThreadedLocal - returning empty');
+        return [];
+    }
+}
+exports.SingleThreadLocalBackgroundManager = SingleThreadLocalBackgroundManager;

package/dist/cjs/background/s3-background-transaction-logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3BackgroundTransactionLogger = void 0;
+const ratchet_aws_1 = require("@bitblit/ratchet-aws");
+const abstract_background_manager_1 = require("./manager/abstract-background-manager");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class S3BackgroundTransactionLogger {
+    constructor(cfg) {
+        this.cfg = cfg;
+        const err = S3BackgroundTransactionLogger.validateConfig(cfg);
+        if (err.length) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Invalid S3BackgroundTransactionLogger config : %j', err);
+        }
+        this.s3TransactionLogCacheRatchet = new ratchet_aws_1.S3CacheRatchet(this.cfg.s3, this.cfg.bucket);
+    }
+    async logTransaction(txLog) {
+        var _a;
+        if (txLog) {
+            if ((_a = txLog.request) === null || _a === void 0 ? void 0 : _a.guid) {
+                await this.s3TransactionLogCacheRatchet.writeObjectToCacheFile(abstract_background_manager_1.AbstractBackgroundManager.backgroundGuidToPath(this.cfg.prefix, txLog.request.guid), txLog);
+            }
+            else {
+                ratchet_common_1.Logger.warn('Could not write transaction record - no guid defined : %j', txLog);
+            }
+        }
+        else {
+            ratchet_common_1.Logger.silly('Skipping write of null log');
+        }
+    }
+    async readTransactionLog(txGuid) {
+        const path = abstract_background_manager_1.AbstractBackgroundManager.backgroundGuidToPath(this.cfg.prefix, txGuid);
+        const log = await this.s3TransactionLogCacheRatchet.fetchCacheFileAsObject(path);
+        return log;
+    }
+    static validateConfig(cfg) {
+        const rval = [];
+        if (cfg) {
+            if (!cfg.s3) {
+                rval.push('You must supply an S3 object');
+            }
+            if (!cfg.bucket) {
+                rval.push('You must supply a bucket');
+            }
+            if (!cfg.timeToLiveDays) {
+                rval.push('You must supply a timeToLiveDays');
+            }
+        }
+        else {
+            rval.push('No config defined');
+        }
+        return rval;
+    }
+}
+exports.S3BackgroundTransactionLogger = S3BackgroundTransactionLogger;

package/dist/cjs/build/ratchet-epsilon-common-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetEpsilonCommonInfo = void 0;
+class RatchetEpsilonCommonInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '85',
+            hash: '7b2bd151314408f02450300b0d5fb0e008d38deb',
+            branch: 'alpha-2023-03-14-1',
+            tag: 'alpha-2023-03-14-1',
+            timeBuiltISO: '2023-03-14T20:58:46-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetEpsilonCommonInfo = RatchetEpsilonCommonInfo;

package/dist/cjs/built-in/background/echo-processor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EchoProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class EchoProcessor {
+    get typeName() {
+        return EchoProcessor.TYPE_NAME;
+    }
+    async handleEvent(data, mgr) {
+        ratchet_common_1.Logger.info('Echo processing : %j', data);
+        if (data && ratchet_common_2.StringRatchet.trimToNull(data['error'])) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Forced error : %s', data['error']);
+        }
+    }
+}
+exports.EchoProcessor = EchoProcessor;
+EchoProcessor.TYPE_NAME = 'EpsilonEcho';

package/dist/cjs/built-in/background/log-and-enqueue-echo-processor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogAndEnqueueEchoProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const echo_processor_1 = require("./echo-processor");
+class LogAndEnqueueEchoProcessor {
+    get typeName() {
+        return 'EpsilonLogAndEnqueueEcho';
+    }
+    async handleEvent(data, cfg) {
+        ratchet_common_1.Logger.info('LogAndEnqueueEchoProcessor : %j', data);
+        await cfg.fireImmediateProcessRequestByParts(echo_processor_1.EchoProcessor.TYPE_NAME, { upstream: data });
+        ratchet_common_1.Logger.info('Completed : LogAndEnqueueEchoProcessor');
+    }
+}
+exports.LogAndEnqueueEchoProcessor = LogAndEnqueueEchoProcessor;

package/dist/cjs/built-in/background/log-message-background-error-processor.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogMessageBackgroundErrorProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class LogMessageBackgroundErrorProcessor {
+    async handleError(submission, error) {
+        ratchet_common_1.Logger.error('-------- ERROR PROCESSED : %j : %s----', submission, error);
+    }
+}
+exports.LogMessageBackgroundErrorProcessor = LogMessageBackgroundErrorProcessor;

package/dist/cjs/built-in/background/no-op-processor.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class NoOpProcessor {
+    get typeName() {
+        return 'EpsilonNoOp';
+    }
+    async handleEvent(data, mgr) {
+        ratchet_common_1.Logger.silly('Hit the no-op proc');
+    }
+}
+exports.NoOpProcessor = NoOpProcessor;

package/dist/cjs/built-in/background/retry-processor.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+class RetryProcessor {
+    constructor(delegate, opts) {
+        this.delegate = delegate;
+        this.opts = opts;
+    }
+    get typeName() {
+        var _a, _b;
+        return ratchet_common_2.StringRatchet.trimToEmpty((_a = this.opts) === null || _a === void 0 ? void 0 : _a.typePrefix) + this.delegate.typeName + ratchet_common_2.StringRatchet.trimToEmpty((_b = this.opts) === null || _b === void 0 ? void 0 : _b.typeSuffix);
+    }
+    async handleEvent(data, mgr) {
+        const tryNumber = data && data[RetryProcessor.RETRY_FIELD_NAME] ? ratchet_common_3.NumberRatchet.safeNumber(data[RetryProcessor.RETRY_FIELD_NAME]) : 1;
+        const dataCopy = data ? Object.assign({}, data) : null;
+        delete dataCopy[RetryProcessor.RETRY_FIELD_NAME];
+        ratchet_common_1.Logger.info('RetryProcessor : %s : Try %d of %d', this.delegate.typeName, tryNumber, this.opts.retryCount);
+        try {
+            await this.delegate.handleEvent(dataCopy, mgr);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Failed to process : %s', err, err);
+            if (tryNumber < this.opts.retryCount) {
+                const waitTimeMS = tryNumber * this.opts.baseDelayMS;
+                ratchet_common_1.Logger.info('Firing automatic retry after a wait of %s', ratchet_common_1.DurationRatchet.formatMsDuration(waitTimeMS));
+                await ratchet_common_1.PromiseRatchet.wait(waitTimeMS);
+                const wrapped = dataCopy || {};
+                wrapped[RetryProcessor.RETRY_FIELD_NAME] = tryNumber + 1;
+                await mgr.fireImmediateProcessRequestByParts(this.typeName, wrapped);
+            }
+            else {
+                ratchet_common_1.Logger.error('That was the last try - giving up');
+            }
+        }
+    }
+}
+exports.RetryProcessor = RetryProcessor;
+RetryProcessor.RETRY_FIELD_NAME = '___RetryProcessorTryNumber';

package/dist/cjs/built-in/background/sample-delay-processor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SampleDelayProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class SampleDelayProcessor {
+    get typeName() {
+        return 'EpsilonSampleDelay';
+    }
+    async handleEvent(data, mgr) {
+        const delayMS = Math.floor(Math.random() * 5000);
+        ratchet_common_1.Logger.info('Running sample processor for %d', delayMS);
+        await ratchet_common_1.PromiseRatchet.wait(delayMS);
+        ratchet_common_1.Logger.info('Sample processor complete');
+    }
+}
+exports.SampleDelayProcessor = SampleDelayProcessor;

package/dist/cjs/built-in/background/sample-input-validated-processor-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/built-in/background/sample-input-validated-processor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SampleInputValidatedProcessor = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class SampleInputValidatedProcessor {
+    get typeName() {
+        return 'EpsilonSampleInputValidated';
+    }
+    async handleEvent(data, mgr) {
+        ratchet_common_1.Logger.info('Running SampleInputValidatedProcessor, data was : %j', data);
+    }
+    get dataSchemaName() {
+        return 'BackgroundSampleInputValidatedProcessorData';
+    }
+}
+exports.SampleInputValidatedProcessor = SampleInputValidatedProcessor;

package/dist/cjs/built-in/built-in-trace-id-generators.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInTraceIdGenerators = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const context_util_1 = require("../util/context-util");
+class BuiltInTraceIdGenerators {
+    static fullAwsRequestId() {
+        let rval = context_util_1.ContextUtil.currentRequestId();
+        rval = rval !== null && rval !== void 0 ? rval : ratchet_common_1.StringRatchet.createType4Guid();
+        return rval;
+    }
+    static shortAwsRequestId() {
+        let rval = BuiltInTraceIdGenerators.fullAwsRequestId();
+        if (rval.length > 10) {
+            let idx = rval.lastIndexOf('-');
+            idx = idx === -1 ? rval.length - 10 : idx;
+            rval = rval.substring(idx);
+        }
+        return rval;
+    }
+    static fixedLengthHex(length = 10) {
+        return ratchet_common_1.StringRatchet.createRandomHexString(length);
+    }
+}
+exports.BuiltInTraceIdGenerators = BuiltInTraceIdGenerators;

package/dist/cjs/built-in/daemon/daemon-authorizer-function.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/built-in/daemon/daemon-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/built-in/daemon/daemon-group-selection-function.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/built-in/daemon/daemon-handler.js

@@ -0,0 +1,62 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonHandler = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const not_found_error_1 = require("../../http/error/not-found-error");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class DaemonHandler {
+    constructor(daemon, inConfig) {
+        this.daemon = daemon;
+        this.inConfig = inConfig;
+        this.config = inConfig || {};
+        this.config.authorizer = this.config.authorizer || DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER;
+        this.config.groupSelector = this.config.groupSelector || ((evt) => Promise.resolve(daemon.defaultGroup));
+        this.config.fetchDaemonStatusByPublicTokenPathParameter =
+            ratchet_common_2.StringRatchet.trimToNull(this.config.fetchDaemonStatusByPublicTokenPathParameter) || 'publicToken';
+        this.config.fetchDaemonStatusPathParameter = ratchet_common_2.StringRatchet.trimToNull(this.config.fetchDaemonStatusPathParameter) || 'key';
+    }
+    async fetchDaemonStatusByPublicToken(evt) {
+        const publicToken = evt.pathParameters[this.config.fetchDaemonStatusByPublicTokenPathParameter];
+        ratchet_common_1.Logger.info('Fetching daemon status for token: %s', publicToken);
+        let rval = await this.daemon.statFromPublicToken(publicToken);
+        const canRead = rval ? await this.config.authorizer(evt, rval) : false;
+        rval = canRead ? rval : null;
+        if (rval === null) {
+            throw new not_found_error_1.NotFoundError('No such token : ' + publicToken);
+        }
+        return rval;
+    }
+    async fetchDaemonStatus(evt) {
+        const daemonKey = evt.pathParameters[this.config.fetchDaemonStatusPathParameter];
+        ratchet_common_1.Logger.info('Fetching daemon status for : %s', daemonKey);
+        let rval = await this.daemon.stat(daemonKey);
+        const canRead = rval ? await this.config.authorizer(evt, rval) : false;
+        rval = canRead ? rval : null;
+        if (rval === null) {
+            throw new not_found_error_1.NotFoundError('No such key : ' + daemonKey);
+        }
+        return rval;
+    }
+    async listDaemonStatus(evt) {
+        const group = await this.config.groupSelector(evt);
+        const keys = await this.daemon.list(group);
+        const allowed = [];
+        for (let i = 0; i < keys.length; i++) {
+            const canRead = await this.config.authorizer(evt, keys[i]);
+            if (canRead) {
+                allowed.push(keys[i]);
+            }
+        }
+        const rval = {
+            results: allowed,
+            nextToken: null,
+        };
+        return rval;
+    }
+}
+exports.DaemonHandler = DaemonHandler;
+_a = DaemonHandler;
+DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER = async (evt, proc) => {
+    return true;
+};

package/dist/cjs/built-in/daemon/daemon-process-state-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });