@aimee-blue/ab-service-kit/lib/shared/logging/logEvents.js

Aimee Blue Service Template

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.logEventsParams = logEventsParams;
exports.logEvents = logEvents;
exports.createTaggedLogEvents = createTaggedLogEvents;

var _rxjs = require("rxjs");

var _basicLogger = require("./basicLogger");

var _notifications = require("../notifications");

var _registerError = require("../registerError");

var _loggingAuditAction = require("./loggingAuditAction");

var _operators = require("rxjs/operators");

function isTagNotification(notification) {
  return notification !== 'audit';
}

function isLogNotification(notification) {
  return typeof notification === 'string';
}

function tagsFromLogOn(notifications) {
  return notifications.filter(isTagNotification);
}

function logOnFromParam(on) {
  if (Array.isArray(on)) {
    const set = new Set(on.filter(isLogNotification));
    return [...set, ...on.filter(entry => !isLogNotification(entry))];
  } else {
    // default:
    return ['next', 'error', 'complete', 'subscribe', 'unsubscribe'];
  }
}

const buildSimpleLog = paramsRaw => {
  return info => {
    var _params$suffix, _params$suffix2, _params$suffix3;

    const params = { ...paramsRaw,
      ...paramsRaw[info.notification]
    };

    try {
      const description = [params.prefix, `(${info.notification})`, ...(params.tags || [])];

      switch (info.notification) {
        case 'next':
          params.logger.log(...description, info.value, ...((_params$suffix = params.suffix) !== null && _params$suffix !== void 0 ? _params$suffix : []));
          break;

        case 'error':
          params.logger.error(...description, info.error, ...((_params$suffix2 = params.suffix) !== null && _params$suffix2 !== void 0 ? _params$suffix2 : []));
          break;

        default:
          params.logger.log(...description, ...((_params$suffix3 = params.suffix) !== null && _params$suffix3 !== void 0 ? _params$suffix3 : []));
          break;
      }
    } catch (err) {
      (0, _registerError.registerError)(err);
      params.logger.error('💥  Something bad happened when logging', err);
    }
  };
};

const buildAuditLog = paramsRaw => info => {
  var _params$suffix4, _params$suffix5, _params$suffix6, _params$suffix7, _params$suffix8;

  const params = { ...paramsRaw,
    ...paramsRaw[info.notification]
  };

  try {
    const description = [params.prefix, ...(params.tags || [])];

    switch (info.notification) {
      case 'audit':
        if (!info.lastValue) {
          break;
        }

        params.logger.log(...description, 'last-observed:', info.lastValue, ...((_params$suffix4 = params.suffix) !== null && _params$suffix4 !== void 0 ? _params$suffix4 : []));
        break;

      case 'unsubscribe':
        params.logger.log(...description, 'last-observed:', info.lastValue, ...((_params$suffix5 = params.suffix) !== null && _params$suffix5 !== void 0 ? _params$suffix5 : []));
        break;

      case 'next':
        params.logger.log(...description, info.value, ...((_params$suffix6 = params.suffix) !== null && _params$suffix6 !== void 0 ? _params$suffix6 : []));
        break;

      case 'error':
        params.logger.log(...description, info.error, ...((_params$suffix7 = params.suffix) !== null && _params$suffix7 !== void 0 ? _params$suffix7 : []));
        break;

      default:
        params.logger.log(...description, ...((_params$suffix8 = params.suffix) !== null && _params$suffix8 !== void 0 ? _params$suffix8 : []));
        break;
    }
  } catch (err) {
    (0, _registerError.registerError)(err);
    params.logger.error('💥  Something bad happened when logging', err);
  }
};

function logEventsParams(arg, defaultLogger = (0, _basicLogger.defaultBasicLogger)()) {
  return {
    logger: defaultLogger,
    ...(typeof arg === 'string' ? {
      prefix: arg
    } : arg)
  };
}

function logEvents(paramsRaw) {
  const params = logEventsParams(paramsRaw);
  const project = params.project;
  const logOn = logOnFromParam(params.on);
  const tags = tagsFromLogOn(logOn);
  const observables = logOn.filter(_rxjs.isObservable); // When the triggering event is another observable we want to
  // log the latest value from source stream

  const operator = logOn.includes('audit') || observables.length > 0 ? (0, _notifications.executeOnNotifications)([...tags, logOn.includes('audit') && (0, _loggingAuditAction.onLoggingAudit)().pipe((0, _operators.mapTo)('audit')) || (0, _rxjs.empty)()], buildAuditLog(params), params.logger) : (0, _notifications.executeOnNotifications)(tags, buildSimpleLog(params), params.logger);

  if (!project) {
    return stream => stream.pipe(operator);
  } else {
    return stream => stream.pipe((0, _operators.publish)(shared => (0, _rxjs.merge)(shared, shared.pipe(project, operator, (0, _operators.ignoreElements)()))));
  }
}

function taggedLogEventsFactory(startWith = [], logger = (0, _basicLogger.defaultBasicLogger)(), fn = logEvents) {
  const tags = [...startWith];

  const taggedlogEvents = paramsRaw => {
    var _params$tags;

    const params = logEventsParams(paramsRaw, logger);
    return fn({ ...params,
      tags: [...((_params$tags = params.tags) !== null && _params$tags !== void 0 ? _params$tags : []), ...tags]
    });
  };

  taggedlogEvents.withTags = (...extraTags) => {
    return taggedLogEventsFactory([...tags, ...extraTags], logger, fn);
  };

  return taggedlogEvents;
}

function createTaggedLogEvents(tags, logger = (0, _basicLogger.defaultBasicLogger)()) {
  return taggedLogEventsFactory(tags, logger);
}
//# sourceMappingURL=logEvents.js.map