workerware.js

/* -----------------------------------------------
/* Authors: wearrrrr
/* GNU General Public License v3.0: https://www.gnu.org/licenses/gpl-3.0.en.html
/* Service Worker Middleware Script
/* ----------------------------------------------- */

importScripts('./WWError.js');
const dbg = console.log.bind(console, '[WorkerWare]');
const time = console.time.bind(console, '[WorkerWare]');
const timeEnd = console.timeEnd.bind(console, '[WorkerWare]');

/*
  OPTS:
    debug - Enables debug logging.
    randomNames - Generate random names for middlewares.
    timing - Logs timing for each middleware.
*/

const defaultOpt = {
  debug: false,
  randomNames: false,
  timing: false,
};

const validEvents = [
  'abortpayment',
  'activate',
  'backgroundfetchabort',
  'backgroundfetchclick',
  'backgroundfetchfail',
  'backgroundfetchsuccess',
  'canmakepayment',
  'contentdelete',
  'cookiechange',
  'fetch',
  'install',
  'message',
  'messageerror',
  'notificationclick',
  'notificationclose',
  'paymentrequest',
  'periodicsync',
  'push',
  'pushsubscriptionchange',
  'sync',
];

class WorkerWare {
  constructor(opt) {
    this._opt = Object.assign({}, defaultOpt, opt);
    this._middlewares = [];
  }
  info() {
    return {
      version: '0.1.0',
      middlewares: this._middlewares,
      options: this._opt,
    };
  }
  use(middleware) {
    let validateMW = this.validateMiddleware(middleware);
    if (validateMW.error) throw new WWError(validateMW.error);
    // This means the middleware is an anonymous function, or the user is silly and named their function "function"
    if (middleware.function.name == 'function')
      middleware.name = crypto.randomUUID();
    if (!middleware.name) middleware.name = middleware.function.name;
    if (this._opt.randomNames) middleware.name = crypto.randomUUID();
    if (this._opt.debug) dbg('Adding middleware:', middleware.name);
    this._middlewares.push(middleware);
  }
  // Run all middlewares for the event type passed in.
  run(event) {
    const middlewares = this._middlewares;
    const returnList = [];
    let fn = async () => {
      for (let i = 0; i < middlewares.length; i++) {
        if (middlewares[i].events.includes(event.type)) {
          if (this._opt.timing) console.time(middlewares[i].name);
          // Add the configuration to the event object.
          event.workerware = {
            config: middlewares[i].configuration || {},
          };
          if (!middlewares[i].explicitCall) {
            let res = await middlewares[i].function(event);
            if (this._opt.timing) console.timeEnd(middlewares[i].name);
            returnList.push(res);
          }
        }
      }
      return returnList;
    };
    return fn;
  }
  deleteByName(middlewareID) {
    if (this._opt.debug) dbg('Deleting middleware:', middlewareID);
    this._middlewares = this._middlewares.filter(
      (mw) => mw.name !== middlewareID
    );
  }
  deleteByEvent(middlewareEvent) {
    if (this._opt.debug) dbg('Deleting middleware by event:', middlewareEvent);
    this._middlewares = this._middlewares.filter(
      (mw) => !mw.events.includes(middlewareEvent)
    );
  }
  get() {
    return this._middlewares;
  }
  /*  
    Run a single middleware by ID.
    This assumes that the user knows what they're doing, and is running the middleware on an event that it's supposed to run on.
  */
  runMW(name, event) {
    const middlewares = this._middlewares;
    if (this._opt.debug) dbg('Running middleware:', name);
    // if (middlewares.includes(name)) {
    //   return middlewares[name](event);
    // } else {
    //   throw new WWError("Middleware not found!");
    // }
    let didCall = false;
    for (let i = 0; i < middlewares.length; i++) {
      if (middlewares[i].name == name) {
        didCall = true;
        event.workerware = {
          config: middlewares[i].configuration || {},
        };
        if (this._opt.timing) console.time(middlewares[i].name);
        let call = middlewares[i].function(event);
        if (this._opt.timing) console.timeEnd(middlewares[i].name);
        return call;
      }
    }
    if (!didCall) {
      throw new WWError('Middleware not found!');
    }
  }
  // type middlewareManifest = {
  //     function: Function,
  //     name?: string,
  //     events: string[], // Should be a union of validEvents.
  //     configuration?: Object // Optional configuration for the middleware.
  // }
  validateMiddleware(middleware) {
    if (!middleware.function)
      return {
        error: 'middleware.function is required',
      };
    if (typeof middleware.function !== 'function')
      return {
        error: 'middleware.function must be typeof function',
      };
    if (
      typeof middleware.configuration !== 'object' &&
      middleware.configuration !== undefined
    ) {
      return {
        error: 'middleware.configuration must be typeof object',
      };
    }
    if (!middleware.events)
      return {
        error: 'middleware.events is required',
      };
    if (!Array.isArray(middleware.events))
      return {
        error: 'middleware.events must be an array',
      };
    if (middleware.events.some((ev) => !validEvents.includes(ev)))
      return {
        error:
          'Invalid event type! Must be one of the following: ' +
          validEvents.join(', '),
      };
    if (
      middleware.explicitCall &&
      typeof middleware.explicitCall !== 'boolean'
    ) {
      return {
        error: 'middleware.explicitCall must be typeof boolean',
      };
    }
    return {
      error: undefined,
    };
  }
}