@bitblit/ratchet-aws 4.0.80-alpha

package/dist/es/daemon/daemon.js

@@ -0,0 +1,122 @@
+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';
+export class Daemon {
+    constructor(s3, bucket, prefix = '', _defaultGroup = Daemon.DEFAULT_DEFAULT_GROUP, jwtRatchet) {
+        this.s3 = s3;
+        this.bucket = bucket;
+        this.prefix = prefix;
+        this._defaultGroup = _defaultGroup;
+        this.jwtRatchet = jwtRatchet;
+        this.cache = new S3CacheRatchet(this.s3, this.bucket);
+    }
+    get defaultGroup() {
+        return this._defaultGroup;
+    }
+    async keyToPublicToken(key, expirationSeconds) {
+        RequireRatchet.notNullOrUndefined(this.jwtRatchet, 'You must set jwtRatchet if you wish to use public tokens');
+        RequireRatchet.notNullOrUndefined(key, 'key');
+        RequireRatchet.true(expirationSeconds > 0, 'Expiration seconds must be larger than 0');
+        const token = { daemonKey: key };
+        const publicToken = await this.jwtRatchet.createTokenString(token, expirationSeconds);
+        return publicToken;
+    }
+    keyToPath(key) {
+        return Buffer.from(key, 'base64').toString();
+    }
+    pathToKey(path) {
+        return Buffer.from(path).toString('base64');
+    }
+    generatePath(group = this._defaultGroup) {
+        return this.generatePrefix(group) + StringRatchet.createType4Guid();
+    }
+    generatePrefix(group = this._defaultGroup) {
+        return this.prefix + group + '/';
+    }
+    async start(options) {
+        options.group = options.group || this._defaultGroup;
+        const path = this.generatePath(options.group);
+        const key = this.pathToKey(path);
+        return DaemonUtil.start(this.cache, key, path, options);
+    }
+    async writeState(newState, contents) {
+        const key = this.keyToPath(newState.id);
+        return DaemonUtil.writeState(this.cache, key, newState, contents);
+    }
+    async clean(group = this._defaultGroup, olderThanSeconds = 60 * 60 * 24 * 7) {
+        try {
+            Logger.info('Daemon removing items older than %d seconds from group %s', olderThanSeconds, group);
+            const original = await this.list(group);
+            const now = new Date().getTime();
+            const removed = [];
+            for (let i = 0; i < original.length; i++) {
+                const test = original[i];
+                const ageSeconds = (now - test.startedEpochMS) / 1000;
+                if (ageSeconds > olderThanSeconds) {
+                    const remove = await this.cache.removeCacheFile(this.keyToPath(test.id));
+                    removed.push(test);
+                }
+            }
+            Logger.debug('Removed %d of %d items', removed.length, original.length);
+            return removed;
+        }
+        catch (err) {
+            Logger.error('Error while trying to clean a daemon: %j %s', group, err);
+            throw err;
+        }
+    }
+    async listKeys(group = this._defaultGroup) {
+        try {
+            const prefix = this.generatePrefix(group);
+            Logger.info('Fetching children of %s', prefix);
+            const rval = await this.cache.directChildrenOfPrefix(prefix);
+            Logger.debug('Found : %j', rval);
+            return rval;
+        }
+        catch (err) {
+            Logger.error('Error while trying to list daemon keys: %j %s', group, err);
+            throw err;
+        }
+    }
+    async list(group = this._defaultGroup) {
+        try {
+            const prefix = this.generatePrefix(group);
+            Logger.info('Fetching children of %s', prefix);
+            const keys = await this.listKeys(group);
+            const proms = keys.map((k) => this.stat(this.pathToKey(this.generatePrefix(group) + k)));
+            const rval = await Promise.all(proms);
+            return rval;
+        }
+        catch (err) {
+            Logger.error('Error while trying to list daemon states: %j %s', group, err);
+            throw err;
+        }
+    }
+    async updateMessage(id, newMessage) {
+        const itemPath = this.keyToPath(id);
+        return DaemonUtil.updateMessage(this.cache, itemPath, newMessage);
+    }
+    async stat(key) {
+        const itemPath = this.keyToPath(key);
+        return DaemonUtil.stat(this.cache, itemPath);
+    }
+    async statFromPublicToken(publicToken) {
+        RequireRatchet.notNullOrUndefined(this.jwtRatchet, 'You must set jwtRatchet if you wish to use public tokens');
+        RequireRatchet.notNullOrUndefined(publicToken, 'publicToken');
+        const parsed = await this.jwtRatchet.decodeToken(publicToken);
+        const key = parsed?.daemonKey;
+        return key ? this.stat(key) : null;
+    }
+    async abort(id) {
+        return DaemonUtil.abort(this.cache, this.keyToPath(id));
+    }
+    async error(id, error) {
+        return DaemonUtil.error(this.cache, this.keyToPath(id), error);
+    }
+    async finalize(id, contents) {
+        return DaemonUtil.finalize(this.cache, this.keyToPath(id), contents);
+    }
+}
+Daemon.DEFAULT_DEFAULT_GROUP = 'DEFAULT';

package/dist/es/dao/prototype-dao-config.js

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

package/dist/es/dao/prototype-dao-db.js

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

package/dist/es/dao/prototype-dao-provider.js

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

package/dist/es/dao/prototype-dao.js

@@ -0,0 +1,84 @@
+import { MapRatchet, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { DateTime } from 'luxon';
+export class PrototypeDao {
+    static defaultDaoConfig() {
+        return {
+            guidCreateFunction: StringRatchet.createType4Guid,
+            guidFieldName: 'guid',
+            createdEpochMSFieldName: 'createdEpochMS',
+            updatedEpochMSFieldName: 'updatedEpochMS',
+            createdUtcTimestampFieldName: null,
+            updatedUtcTimestampFieldName: null,
+        };
+    }
+    constructor(provider, cfg = PrototypeDao.defaultDaoConfig()) {
+        this.provider = provider;
+        this.cfg = cfg;
+        RequireRatchet.notNullOrUndefined(provider, 'provider');
+        RequireRatchet.notNullOrUndefined(cfg, 'cfg');
+        RequireRatchet.notNullOrUndefined(cfg.guidCreateFunction, 'cfg.guidCreateFunction');
+        RequireRatchet.notNullOrUndefined(cfg.guidFieldName, 'cfg.guidFieldName');
+    }
+    async fetchAll() {
+        const db = await this.provider.loadDatabase();
+        return db.items || [];
+    }
+    async resetDatabase() {
+        await this.provider.storeDatabase({ items: [], lastModifiedEpochMS: Date.now() });
+    }
+    async removeItems(guids) {
+        let old = await this.fetchAll();
+        if (guids) {
+            old = old.filter((t) => !guids.includes(t[this.cfg.guidFieldName]));
+            await this.provider.storeDatabase({ items: old, lastModifiedEpochMS: Date.now() });
+        }
+        return old;
+    }
+    async store(value) {
+        let old = await this.fetchAll();
+        if (value) {
+            value[this.cfg.guidFieldName] = value[this.cfg.guidFieldName] || this.cfg.guidCreateFunction();
+            if (this.cfg.createdEpochMSFieldName) {
+                value[this.cfg.createdEpochMSFieldName] = value[this.cfg.createdEpochMSFieldName] || Date.now();
+            }
+            if (this.cfg.createdUtcTimestampFieldName) {
+                value[this.cfg.createdUtcTimestampFieldName] = value[this.cfg.createdUtcTimestampFieldName] || DateTime.utc().toISO();
+            }
+            if (this.cfg.updatedEpochMSFieldName) {
+                value[this.cfg.updatedEpochMSFieldName] = Date.now();
+            }
+            if (this.cfg.updatedUtcTimestampFieldName) {
+                value[this.cfg.updatedUtcTimestampFieldName] = DateTime.utc().toISO();
+            }
+            old = old.filter((t) => t[this.cfg.guidFieldName] !== value[this.cfg.guidFieldName]);
+            old.push(value);
+            await this.provider.storeDatabase({ items: old, lastModifiedEpochMS: Date.now() });
+        }
+        return value;
+    }
+    async fetchById(guid) {
+        const old = await this.fetchAll();
+        return old.find((t) => t[this.cfg.guidFieldName] === guid);
+    }
+    async searchByField(fieldDotPath, fieldValue) {
+        RequireRatchet.notNullOrUndefined(fieldDotPath, 'fieldDotPath');
+        RequireRatchet.notNullOrUndefined(fieldValue, 'fieldValue');
+        const map = {};
+        map[fieldDotPath] = fieldValue;
+        return this.searchByFieldMap(map);
+    }
+    async searchByFieldMap(input) {
+        RequireRatchet.notNullOrUndefined(input, 'input');
+        let old = await this.fetchAll();
+        old = old.filter((t) => {
+            let matchAll = true;
+            Object.keys(input).forEach((k) => {
+                const val = MapRatchet.findValueDotPath(t, k);
+                const fieldValue = input[k];
+                matchAll = matchAll && val === fieldValue;
+            });
+            return matchAll;
+        });
+        return old;
+    }
+}

package/dist/es/dao/s3-prototype-dao-provider.js

@@ -0,0 +1,24 @@
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class S3PrototypeDaoProvider {
+    constructor(s3CacheRatchet, keyName) {
+        this.s3CacheRatchet = s3CacheRatchet;
+        this.keyName = keyName;
+        RequireRatchet.notNullOrUndefined(s3CacheRatchet, 's3CacheRatchet');
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(s3CacheRatchet.getDefaultBucket(), 's3CacheRatchet.defaultBucket');
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(keyName, 'keyName');
+    }
+    async storeDatabase(inDb) {
+        const toSave = inDb || { items: [], lastModifiedEpochMS: null };
+        toSave.lastModifiedEpochMS = Date.now();
+        const put = await this.s3CacheRatchet.writeObjectToCacheFile(this.keyName, toSave);
+        const rval = !!put;
+        return rval;
+    }
+    async loadDatabase() {
+        const rval = (await this.s3CacheRatchet.fetchCacheFileAsObject(this.keyName)) || {
+            items: [],
+            lastModifiedEpochMS: Date.now(),
+        };
+        return rval;
+    }
+}

package/dist/es/dao/s3-simple-dao.js

@@ -0,0 +1,74 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class S3SimpleDao {
+    constructor(cache, prefix) {
+        this.cache = cache;
+        this.prefix = prefix;
+        if (!cache) {
+            throw new Error('cache object may not be null');
+        }
+        if (!cache.getDefaultBucket()) {
+            throw new Error('Supplied cache must have default bucket set');
+        }
+    }
+    buildPathPrefix(path) {
+        let rval = '';
+        if (this.prefix) {
+            rval += this.prefix;
+        }
+        if (path) {
+            rval += path;
+        }
+        return rval;
+    }
+    buildFullPath(id, path) {
+        let rval = this.buildPathPrefix(path);
+        if (rval.length > 0) {
+            rval += '/';
+        }
+        rval += id + '.json';
+        return rval;
+    }
+    async exists(id, path) {
+        const fullPath = this.buildFullPath(id, path);
+        Logger.debug('Check file existence : %s', fullPath);
+        return this.cache.fileExists(fullPath);
+    }
+    async fetch(id, path) {
+        const fullPath = this.buildFullPath(id, path);
+        Logger.debug('Fetching : %s', fullPath);
+        const rval = (await this.cache.fetchCacheFileAsObject(fullPath));
+        rval.id = id;
+        rval.path = path;
+        return rval;
+    }
+    async store(item, path) {
+        item.id = item.id || StringRatchet.createType4Guid();
+        item.lastModifiedEpochMS = new Date().getTime();
+        const fullPath = this.buildFullPath(item.id, path);
+        Logger.debug('Storing : %s', fullPath);
+        const stored = await this.cache.writeObjectToCacheFile(fullPath, item);
+        const read = await this.fetch(item.id, path);
+        return read;
+    }
+    async listItems(path) {
+        const fullPath = this.buildPathPrefix(path);
+        Logger.debug('Listing : %s', fullPath);
+        const rval = await this.cache.directChildrenOfPrefix(fullPath);
+        return rval;
+    }
+    async fetchItemsInPath(path) {
+        const fullPath = this.buildPathPrefix(path);
+        Logger.debug('Full fetch of : %s', fullPath);
+        const items = await this.listItems(path);
+        const promises = items.map((s) => this.fetch(s, path));
+        const rval = await Promise.all(promises);
+        return rval;
+    }
+    async delete(id, path) {
+        const fullPath = this.buildFullPath(id, path);
+        Logger.debug('Deleting : %s', fullPath);
+        const del = await this.cache.removeCacheFile(fullPath);
+        return del != null;
+    }
+}

package/dist/es/dao/simple-dao-item.js

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

package/dist/es/dynamodb/dynamo-ratchet-like.js

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