readiness-manager 1.1.4 → 1.2.0-rc.x6cd566eea

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@fiverr-private/typescript-configuration/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "composite": true,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist", "**/*spec.ts"]
+}

package/LICENSE

@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright (c) Fiverr
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./src');

package/src/constants.js

@@ -1,14 +0,0 @@
-/**
- * The possible beacon status.
- * @type {{ NOT_STARTED: string, RESOLVED: string, PENDING: string, REJECTED: string }}
- */
-const BeaconStatus = {
-    NOT_STARTED: 'not_started',
-    PENDING: 'pending',
-    RESOLVED: 'resolved',
-    REJECTED: 'rejected'
-};
-
-module.exports = {
-    BeaconStatus
-};

package/src/error.js

@@ -1,42 +0,0 @@
-/**
- * The possible errors that could be thrown.
- * @type {Object<string>}
- */
-const ERRORS = {
-    BEACON_ALREADY_EXISTS: 'Beacon is already exists, please ensure to use a unique name per beacon',
-    BEACON_DOES_NOT_EXISTS: 'Beacon does not exists, make sure to call `register` before trying to set beacon ready hook.',
-    BEACON_EXECUTION_FAILED: 'Beacon execution failed'
-};
-
-/**
- * The custom error the be thrown when beacon execution fails.
- * @type {ActionExecutionError}
- */
-class ActionExecutionError extends Error {
-    constructor(name, attempt, error) {
-        super();
-
-        Object.assign(this, {
-            message: ERRORS.BEACON_EXECUTION_FAILED,
-            name,
-            attempt,
-            stack: error.stack,
-            failReason: error.message
-        });
-    }
-}
-
-/**
- * Default error handler to be triggered upon beacon errors.
- * @param beaconError - The beacon error that occur.
- * @type {ActionErrorHandler}
- */
-const defaultErrorHandler = (
-    beaconError
-) => console.log(beaconError); // eslint-disable-line no-console
-
-module.exports = {
-    ERRORS,
-    ActionExecutionError,
-    defaultErrorHandler
-};

package/src/index.js

@@ -1,208 +0,0 @@
-const {
-    ERRORS,
-    ActionExecutionError,
-    defaultErrorHandler
-} = require('./error');
-const { BeaconStatus } = require('./constants');
-
-/**
- * Sets of private attributes which should not be exposed / accessed by consumer.
- * @type {Object<Symbol>}
- */
-const Symbols = [
-    'beacons',
-    'callbacks',
-    'execute',
-    'trackBeaconUpdate',
-    'updateBeacon',
-    'errorHandler'
-].reduce((acc, key) => ({ ...acc, [key]: Symbol() }), {});
-
-/**
- * The internal "ready" state to determine process readiness.
- * @type {boolean}
- */
-let readyState = false;
-
-/**
- * @type {ReadinessManager}
- */
-class ReadinessManager {
-    constructor() {
-        this[Symbols.beacons] = {};
-        this[Symbols.callbacks] = [];
-        this[Symbols.errorHandler] = defaultErrorHandler;
-
-        this[Symbols.execute] = this[Symbols.execute].bind(this);
-    }
-
-    /**
-     * Returns true if current process state is considered as "ready".
-     * @return {boolean}
-     */
-    get ready() {
-        return readyState;
-    }
-
-    /**
-     * Returns current registered actions status
-     * @return {ActionsStatus}
-     */
-    status() {
-        return Object.values(this[Symbols.beacons])
-            .reduce((acc, { name, status }) => {
-                const current = acc[status] || [];
-                return Object.assign(acc, { [status]: [...current, name] });
-            }, {});
-    }
-
-    /**
-     * Registers a given name and action as beacon under manager.
-     * @param {string} name - The operation name to register with.
-     * @param {ReadyAction} action - The ready emitter to condition the process readiness with.
-     */
-    register(name, action) {
-        if (this.ready) { return; }
-
-        if (this[Symbols.beacons][name]) { throw new Error(ERRORS.BEACON_ALREADY_EXISTS); }
-
-        const beacon = {
-            name,
-            action,
-            callbacks: [],
-            status: BeaconStatus.NOT_STARTED
-        };
-
-        Object.assign(this[Symbols.beacons], { [name]: beacon });
-    }
-
-    /**
-     * Runs current registered beacons execution to determine process "ready" state.
-     * @return {ReadinessManager}
-     */
-    run() {
-        readyState = false;
-
-        Object.values(this[Symbols.beacons])
-            .forEach((beacon) => this[Symbols.execute](beacon));
-
-        return this;
-    }
-
-    /**
-     * Registers a given callback to be triggered once process is marked as "ready".
-     * @param {ReadyCallback} callback
-     * @return {ReadinessManager}
-     */
-    onReady(callback) {
-        if (readyState) {
-            // Invokes immediately given callback if process is already ready.
-            callback();
-            return this;
-        }
-
-        this[Symbols.callbacks].push(callback);
-        return this;
-    }
-
-    /**
-     * Registers a given callback on a specific action resolved..
-     * @param {string} name - The name of the action the callback should be attached to.
-     * @param {ReadyCallback} callback - The callback to run upon beacon resolved.
-     * @return {ReadinessManager}
-     */
-    onActionReady(name, callback) {
-        const beacon = this[Symbols.beacons][name];
-        if (!beacon) { throw new Error(ERRORS.BEACON_DOES_NOT_EXISTS); }
-
-        if (beacon.status === BeaconStatus.RESOLVED) {
-            // Invokes immediately given callback if beacon status is already resolved.
-            return callback();
-        }
-
-        this[Symbols.beacons][name].callbacks.push(callback);
-        return this;
-    }
-
-    /**
-     * Registers a given error handler under manager errors.
-     * @param {ActionErrorHandler} errorHandler - The handler to trigger upon action errors.
-     * @return {ReadinessManager}
-     */
-    onError(errorHandler) {
-        Object.assign(this, { [Symbols.errorHandler]: errorHandler });
-        return this;
-    }
-
-    /**
-     * Tracks a given beacon action.
-     * @param {Beacon} beacon - The beacon to execute.
-     * @param {Number} attempt - The attempt number of current beacon execution.
-     * @throws {ActionExecutionError}
-     * @private
-     */
-    async [Symbols.execute](beacon, attempt = 1) {
-        const { name, action } = beacon;
-
-        const update = (status) => this[Symbols.updateBeacon](name, status);
-
-        update(BeaconStatus.PENDING);
-
-        try {
-            // The actual beacon execution we want to keep track on.
-            const result = action();
-
-            if (result instanceof Promise) {
-                await result;
-            }
-
-            update(BeaconStatus.RESOLVED);
-        } catch (error) {
-            update(BeaconStatus.REJECTED);
-
-            // Invokes consumer error hook with a retry method and the beacon error.
-            this[Symbols.errorHandler](
-                new ActionExecutionError(name, attempt, error),
-                () => this[Symbols.execute](beacon, attempt + 1)
-            );
-        }
-    }
-
-    /**
-     * Updates a given beacon name with a given status.
-     * @param name - The beacon name to update.
-     * @param status - The beacon status to set.
-     * @private
-     */
-    [Symbols.updateBeacon](name, status) {
-        Object.assign(
-            this[Symbols.beacons][name],
-            { status }
-        );
-
-        // Resolves specific beacon ready listeners.
-        if (status === BeaconStatus.RESOLVED) {
-            this[Symbols.beacons][name].callbacks.map(
-                (callback) => callback()
-            );
-        }
-
-        this[Symbols.trackBeaconUpdate]();
-    }
-
-    /**
-     * Tracks an beacon update event, checks whether process is "ready".
-     * If so, will trigger registered `onReady` callbacks.
-     * @private
-     */
-    [Symbols.trackBeaconUpdate]() {
-        if (readyState) { return; }
-
-        readyState = Object.values(this[Symbols.beacons])
-            .every((beacon) => beacon.status === BeaconStatus.RESOLVED);
-
-        readyState && this[Symbols.callbacks].map((callback) => callback());
-    }
-}
-
-module.exports = new ReadinessManager();

package/src/types.d.ts

@@ -1,40 +0,0 @@
-type ReadyCallback = () => void;
-type ReadyAction = () => unknown | Promise<unknown>;
-type ActionRetry = () => Promise<unknown>;
-type ActionStatus = 'not_started' | 'pending' | 'resolved' | 'rejected';
-
-interface Beacon {
-    name: string;
-    action: ReadyAction;
-    status: ActionStatus;
-    callbacks: ReadyCallback[];
-}
-
-type BeaconsMap = { [name: string] : Beacon };
-
-export interface ActionExecutionError extends Error {
-    name: string;
-    stack: string;
-    attempt: number;
-    failReason: string;
-}
-
-export type ActionErrorHandler = (error: ActionExecutionError, retry: ActionRetry) => void;
-
-export type ActionsStatus = {
-    [status in ActionStatus]: string[];
-};
-
-export interface ReadinessManager {
-    register: (name: string, action: ReadyAction) => void;
-    run: () => ReadinessManager;
-    onReady:(callback: ReadyCallback) => ReadinessManager;
-    onActionReady:(name: string, callback: ReadyCallback) => ReadinessManager;
-    onError:(errorHandler: ActionErrorHandler) => ReadinessManager;
-    status:() => ActionsStatus;
-    ready: boolean;
-}
-
-declare const manager: ReadinessManager;
-
-export default manager;

package/tests/mock.d.ts

@@ -1,9 +0,0 @@
-import { ReadinessManager } from '../src/types';
-
-export interface ReadinessManagerMock extends ReadinessManager{
-    setReady: (isReady: boolean) => void;
-}
-
-declare const manager: ReadinessManagerMock;
-
-export default manager;

package/tests/mock.js

@@ -1,36 +0,0 @@
-/**
- * Test mock helper class.
- */
-class ReadinessManagerMock {
-    constructor() {
-        this._ready = false;
-    }
-
-    get ready() {
-        return this._ready;
-    }
-
-    status() {
-        return {};
-    }
-
-    setReady(isReady) {
-        this._ready = isReady;
-    }
-
-    register() { return undefined; }
-
-    orchestrate() {
-        this._ready = true;
-    }
-
-    onReady(callback) {
-        callback();
-    }
-
-    onActionReady(callback) {
-        callback();
-    }
-}
-
-module.exports = new ReadinessManagerMock();