ng-talkback 21.0.14 → 21.0.17

package/lib-prod/index.js

@@ -1,37 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.talkback = void 0;
 let a = 2;
 a++;
-//#region @backend
-__exportStar(require("./options.backend"), exports);
-__exportStar(require("./tape.backend"), exports);
-const talkback_factory_backend_1 = require("./talkback-factory.backend");
-const options_backend_1 = require("./options.backend");
+export * from "./options.backend";
+export * from "./tape.backend";
+import TalkbackFactory from "./talkback-factory.backend";
+import { DefaultOptions, FallbackMode, RecordMode } from "./options.backend";
 const talkbackFn = (options) => {
-    return talkback_factory_backend_1.default.server(options);
+  return TalkbackFactory.server(options);
 };
 talkbackFn.Options = {
-    Default: options_backend_1.DefaultOptions,
-    FallbackMode: options_backend_1.FallbackMode,
-    RecordMode: options_backend_1.RecordMode
+  Default: DefaultOptions,
+  FallbackMode,
+  RecordMode
+};
+talkbackFn.requestHandler = (options) => TalkbackFactory.requestHandler(options);
+const talkback = talkbackFn;
+var index_default = talkbackFn;
+export {
+  index_default as default,
+  talkback
 };
-talkbackFn.requestHandler = (options) => talkback_factory_backend_1.default.requestHandler(options);
-exports.talkback = talkbackFn;
-exports.default = talkbackFn;
-//#endregion
-//# sourceMappingURL=index.js.map

package/lib-prod/logger.backend.js

@@ -1,26 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 class Logger {
-    options;
-    constructor(options) {
-        this.options = options;
-        if (this.options.debug) {
-            console.debug("DEBUG mode active");
-        }
+  options;
+  constructor(options) {
+    this.options = options;
+    if (this.options.debug) {
+      console.debug("DEBUG mode active");
     }
-    log(message) {
-        if (!this.options.silent || this.options.debug) {
-            console.log(message);
-        }
+  }
+  log(message) {
+    if (!this.options.silent || this.options.debug) {
+      console.log(message);
     }
-    debug(message) {
-        if (this.options.debug) {
-            console.debug(message);
-        }
-    }
-    error(message) {
-        console.error(message);
+  }
+  debug(message) {
+    if (this.options.debug) {
+      console.debug(message);
     }
+  }
+  error(message) {
+    console.error(message);
+  }
 }
-exports.default = Logger;
-//# sourceMappingURL=logger.backend.js.map
+export {
+  Logger as default
+};

package/lib-prod/migrations/index.js

@@ -1,19 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-//@ts-nocheck
-__exportStar(require("./migrations_index._auto-generated_"), exports);
-//# sourceMappingURL=index.js.map
+export * from "./migrations_index._auto-generated_";

package/lib-prod/migrations/migrations_index._auto-generated_.js

@@ -1,4 +0,0 @@
-// THIS FILE IS GENERATED - DO NOT MODIFY
-// THIS FILE IS GENERATED - DO NOT MODIFY
-// THIS FILE IS GENERATED - DO NOT MODIFY
-//# sourceMappingURL=migrations_index._auto-generated_.js.map

package/lib-prod/options.backend.js

@@ -1,91 +1,95 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultOptions = exports.FallbackMode = exports.RecordMode = void 0;
-const logger_backend_1 = require("./logger.backend");
-exports.RecordMode = {
-    NEW: "NEW", // If no tape matches the request, proxy it and save the response to a tape
-    OVERWRITE: "OVERWRITE", // Always proxy the request and save the response to a tape, overwriting any existing one
-    DISABLED: "DISABLED", // If a matching tape exists, return it. Otherwise, don't proxy the request and use `fallbackMode` for the response
-    ALL: []
+import Logger from "./logger.backend";
+const RecordMode = {
+  NEW: "NEW",
+  // If no tape matches the request, proxy it and save the response to a tape
+  OVERWRITE: "OVERWRITE",
+  // Always proxy the request and save the response to a tape, overwriting any existing one
+  DISABLED: "DISABLED",
+  // If a matching tape exists, return it. Otherwise, don't proxy the request and use `fallbackMode` for the response
+  ALL: []
 };
-exports.RecordMode.ALL = [exports.RecordMode.NEW, exports.RecordMode.OVERWRITE, exports.RecordMode.DISABLED];
-exports.FallbackMode = {
-    NOT_FOUND: "NOT_FOUND",
-    PROXY: "PROXY",
-    ALL: []
+RecordMode.ALL = [RecordMode.NEW, RecordMode.OVERWRITE, RecordMode.DISABLED];
+const FallbackMode = {
+  NOT_FOUND: "NOT_FOUND",
+  PROXY: "PROXY",
+  ALL: []
 };
-exports.FallbackMode.ALL = [exports.FallbackMode.NOT_FOUND, exports.FallbackMode.PROXY];
-exports.DefaultOptions = {
-    host: "",
-    port: 8080,
-    path: "./tapes/",
-    record: exports.RecordMode.NEW,
-    fallbackMode: exports.FallbackMode.NOT_FOUND,
-    name: "unnamed",
-    tapeNameGenerator: undefined,
-    https: {
-        enabled: false,
-        keyPath: undefined,
-        certPath: undefined
-    },
-    ignoreHeaders: ["content-length", "host"],
-    ignoreQueryParams: [],
-    ignoreBody: false,
-    bodyMatcher: undefined,
-    urlMatcher: undefined,
-    requestDecorator: undefined,
-    responseDecorator: undefined,
-    tapeDecorator: undefined,
-    latency: 0,
-    errorRate: 0,
-    silent: false,
-    summary: true,
-    debug: false,
-    logger: new logger_backend_1.default({})
+FallbackMode.ALL = [FallbackMode.NOT_FOUND, FallbackMode.PROXY];
+const DefaultOptions = {
+  host: "",
+  port: 8080,
+  path: "./tapes/",
+  record: RecordMode.NEW,
+  fallbackMode: FallbackMode.NOT_FOUND,
+  name: "unnamed",
+  tapeNameGenerator: void 0,
+  https: {
+    enabled: false,
+    keyPath: void 0,
+    certPath: void 0
+  },
+  ignoreHeaders: ["content-length", "host"],
+  ignoreQueryParams: [],
+  ignoreBody: false,
+  bodyMatcher: void 0,
+  urlMatcher: void 0,
+  requestDecorator: void 0,
+  responseDecorator: void 0,
+  tapeDecorator: void 0,
+  latency: 0,
+  errorRate: 0,
+  silent: false,
+  summary: true,
+  debug: false,
+  logger: new Logger({})
 };
 class OptionsFactory {
-    static logger;
-    static prepare(usrOpts = {}) {
-        const opts = {
-            ...exports.DefaultOptions,
-            name: usrOpts.host,
-            ...usrOpts,
-            ignoreHeaders: [
-                ...exports.DefaultOptions.ignoreHeaders,
-                ...(usrOpts.ignoreHeaders || [])
-            ]
-        };
-        this.logger = new logger_backend_1.default(opts);
-        opts.logger = this.logger;
-        this.validateOptions(opts);
-        return opts;
+  static logger;
+  static prepare(usrOpts = {}) {
+    const opts = {
+      ...DefaultOptions,
+      name: usrOpts.host,
+      ...usrOpts,
+      ignoreHeaders: [
+        ...DefaultOptions.ignoreHeaders,
+        ...usrOpts.ignoreHeaders || []
+      ]
+    };
+    this.logger = new Logger(opts);
+    opts.logger = this.logger;
+    this.validateOptions(opts);
+    return opts;
+  }
+  static validateOptions(opts) {
+    this.validateRecord(opts.record);
+    this.validateFallbackMode(opts.fallbackMode);
+    this.validateLatency(opts.latency);
+    this.validateErrorRate(opts.errorRate);
+  }
+  static validateRecord(record) {
+    if (typeof record === "string" && !RecordMode.ALL.includes(record)) {
+      throw `INVALID OPTION: record has an invalid value of '${record}'`;
     }
-    static validateOptions(opts) {
-        this.validateRecord(opts.record);
-        this.validateFallbackMode(opts.fallbackMode);
-        this.validateLatency(opts.latency);
-        this.validateErrorRate(opts.errorRate);
+  }
+  static validateFallbackMode(fallbackMode) {
+    if (typeof fallbackMode === "string" && !FallbackMode.ALL.includes(fallbackMode)) {
+      throw `INVALID OPTION: fallbackMode has an invalid value of '${fallbackMode}'`;
     }
-    static validateRecord(record) {
-        if (typeof (record) === "string" && !exports.RecordMode.ALL.includes(record)) {
-            throw `INVALID OPTION: record has an invalid value of '${record}'`;
-        }
+  }
+  static validateLatency(latency) {
+    if (Array.isArray(latency) && latency.length !== 2) {
+      throw `Invalid LATENCY option. If using a range, the array should only have 2 values [min, max]. Current=[${latency}]`;
     }
-    static validateFallbackMode(fallbackMode) {
-        if (typeof (fallbackMode) === "string" && !exports.FallbackMode.ALL.includes(fallbackMode)) {
-            throw `INVALID OPTION: fallbackMode has an invalid value of '${fallbackMode}'`;
-        }
-    }
-    static validateLatency(latency) {
-        if (Array.isArray(latency) && latency.length !== 2) {
-            throw `Invalid LATENCY option. If using a range, the array should only have 2 values [min, max]. Current=[${latency}]`;
-        }
-    }
-    static validateErrorRate(errorRate) {
-        if (typeof (errorRate) !== "function" && (errorRate < 0 || errorRate > 100)) {
-            throw `Invalid ERRORRATE option. Value should be between 0 and 100. Current=[${errorRate}]`;
-        }
+  }
+  static validateErrorRate(errorRate) {
+    if (typeof errorRate !== "function" && (errorRate < 0 || errorRate > 100)) {
+      throw `Invalid ERRORRATE option. Value should be between 0 and 100. Current=[${errorRate}]`;
     }
+  }
 }
-exports.default = OptionsFactory;
-//# sourceMappingURL=options.backend.js.map
+export {
+  DefaultOptions,
+  FallbackMode,
+  RecordMode,
+  OptionsFactory as default
+};

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "ng-talkback/lib-prod",
-  "version": "21.0.14"
+  "version": "21.0.17"
 }

package/lib-prod/request-handler.backend.js

@@ -1,145 +1,131 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const uuid_1 = require("uuid");
-const axios_1 = require("axios");
-const tape_backend_1 = require("./tape.backend");
-const options_backend_1 = require("./options.backend");
-const error_rate_backend_1 = require("./features/error-rate.backend");
-const latency_backend_1 = require("./features/latency.backend");
+import { v4 as uuidv4 } from "uuid";
+import axios from "axios";
+import Tape from "./tape.backend";
+import OptionsFactory, { RecordMode, FallbackMode } from "./options.backend";
+import ErrorRate from "./features/error-rate.backend";
+import Latency from "./features/latency.backend";
 class RequestHandler {
-    tapeStore;
-    options;
-    errorRate;
-    latency;
-    constructor(tapeStore, options) {
-        this.tapeStore = tapeStore;
-        this.options = options;
-        this.errorRate = new error_rate_backend_1.default(this.options);
-        this.latency = new latency_backend_1.default(this.options);
+  tapeStore;
+  options;
+  errorRate;
+  latency;
+  constructor(tapeStore, options) {
+    this.tapeStore = tapeStore;
+    this.options = options;
+    this.errorRate = new ErrorRate(this.options);
+    this.latency = new Latency(this.options);
+  }
+  async handle(req) {
+    const matchingContext = {
+      id: uuidv4()
+    };
+    const recordMode = typeof this.options.record === "string" ? this.options.record : this.options.record(req);
+    OptionsFactory.validateRecord(recordMode);
+    if (this.options.requestDecorator) {
+      req = this.options.requestDecorator(req, matchingContext);
+      if (!req) {
+        throw new Error("requestDecorator didn't return a req object");
+      }
     }
-    async handle(req) {
-        const matchingContext = {
-            id: (0, uuid_1.v4)()
-        };
-        const recordMode = typeof (this.options.record) === "string" ? this.options.record : this.options.record(req);
-        options_backend_1.default.validateRecord(recordMode);
-        if (this.options.requestDecorator) {
-            req = this.options.requestDecorator(req, matchingContext);
-            if (!req) {
-                throw new Error("requestDecorator didn't return a req object");
-            }
+    let newTape = new Tape(req, this.options);
+    let matchingTape = this.tapeStore.find(newTape);
+    let resObj, responseTape;
+    if (recordMode !== RecordMode.OVERWRITE && matchingTape) {
+      responseTape = matchingTape;
+      if (this.errorRate.shouldSimulate(req, matchingTape)) {
+        return this.errorRate.simulate(req);
+      }
+      await this.latency.simulate(req, matchingTape);
+    } else {
+      if (matchingTape) {
+        responseTape = matchingTape;
+      } else {
+        responseTape = newTape;
+      }
+      if (recordMode === RecordMode.NEW || recordMode === RecordMode.OVERWRITE) {
+        resObj = await this.makeRealRequest(req);
+        responseTape.res = { ...resObj };
+        if (this.options.tapeDecorator) {
+          responseTape = this.options.tapeDecorator(responseTape, matchingContext);
+          if (!responseTape) {
+            throw new Error("tapeDecorator didn't return a tape object");
+          }
         }
-        let newTape = new tape_backend_1.default(req, this.options);
-        let matchingTape = this.tapeStore.find(newTape);
-        let resObj, responseTape;
-        if (recordMode !== options_backend_1.RecordMode.OVERWRITE && matchingTape) {
-            responseTape = matchingTape;
-            if (this.errorRate.shouldSimulate(req, matchingTape)) {
-                return this.errorRate.simulate(req);
-            }
-            await this.latency.simulate(req, matchingTape);
-        }
-        else {
-            if (matchingTape) {
-                responseTape = matchingTape;
-            }
-            else {
-                responseTape = newTape;
-            }
-            if (recordMode === options_backend_1.RecordMode.NEW || recordMode === options_backend_1.RecordMode.OVERWRITE) {
-                resObj = await this.makeRealRequest(req);
-                responseTape.res = { ...resObj };
-                if (this.options.tapeDecorator) {
-                    responseTape = this.options.tapeDecorator(responseTape, matchingContext);
-                    if (!responseTape) {
-                        throw new Error("tapeDecorator didn't return a tape object");
-                    }
-                }
-                await this.tapeStore.save(responseTape);
-            }
-            else {
-                resObj = await this.onNoRecord(req);
-                responseTape.res = { ...resObj };
-            }
-        }
-        resObj = responseTape.res;
-        if (this.options.responseDecorator) {
-            const clonedTape = await responseTape.clone();
-            const resTape = this.options.responseDecorator(clonedTape, req, matchingContext);
-            if (!resTape) {
-                throw new Error("responseDecorator didn't return a tape object");
-            }
-            if (resTape.res.headers["content-length"]) {
-                resTape.res.headers["content-length"] = resTape.res.body.length;
-            }
-            resObj = resTape.res;
-        }
-        return resObj;
+        await this.tapeStore.save(responseTape);
+      } else {
+        resObj = await this.onNoRecord(req);
+        responseTape.res = { ...resObj };
+      }
     }
-    async onNoRecord(req) {
-        const fallbackMode = typeof (this.options.fallbackMode) === "string" ? this.options.fallbackMode : this.options.fallbackMode(req);
-        options_backend_1.default.validateFallbackMode(fallbackMode);
-        this.options.logger.log(`Tape for ${req.url} not found and recording is disabled (fallbackMode: ${fallbackMode})`);
-        this.options.logger.log({
-            url: req.url,
-            headers: req.headers
-        });
-        if (fallbackMode === options_backend_1.FallbackMode.PROXY) {
-            if (this.errorRate.shouldSimulate(req, undefined)) {
-                return this.errorRate.simulate(req);
-            }
-            await this.latency.simulate(req, undefined);
-            return await this.makeRealRequest(req);
-        }
-        return {
-            status: 404,
-            headers: { "content-type": ["text/plain"] },
-            body: Buffer.from("talkback - tape not found")
-        };
+    resObj = responseTape.res;
+    if (this.options.responseDecorator) {
+      const clonedTape = await responseTape.clone();
+      const resTape = this.options.responseDecorator(clonedTape, req, matchingContext);
+      if (!resTape) {
+        throw new Error("responseDecorator didn't return a tape object");
+      }
+      if (resTape.res.headers["content-length"]) {
+        resTape.res.headers["content-length"] = resTape.res.body.length;
+      }
+      resObj = resTape.res;
     }
-    async makeRealRequest(req) {
-        // let fetchBody: Buffer | null
-        let { method, url, body } = req;
-        // fetchBody = body
-        const headers = { ...req.headers };
-        delete headers.host;
-        const host = this.options.host;
-        // this.options.logger.log(`Making real request to ${host}${url}`)
-        // if (method === "GET" || method === "HEAD") {
-        //   fetchBody = null
-        // }
-        let urlToGetData = `${host}${url}`;
-        // console.log(`host: "${urlToGetData}"` )
-        // console.log(`url: "${url}"` )
-        var fRes = {
-            status: 400,
-            headers: {},
-            body: new Buffer('')
-        };
-        try {
-            // console.log(body.toString())
-            const r = await (0, axios_1.default)({
-                url: urlToGetData,
-                method,
-                headers,
-                data: body,
-                responseType: 'arraybuffer',
-            });
-            fRes = {
-                status: r.status,
-                headers: r.headers,
-                body: r.data
-            };
-        }
-        catch (err) {
-            fRes = {
-                status: err?.response?.status,
-                headers: err?.response?.headers,
-                body: err?.response?.data
-            };
-        }
-        return fRes;
+    return resObj;
+  }
+  async onNoRecord(req) {
+    const fallbackMode = typeof this.options.fallbackMode === "string" ? this.options.fallbackMode : this.options.fallbackMode(req);
+    OptionsFactory.validateFallbackMode(fallbackMode);
+    this.options.logger.log(`Tape for ${req.url} not found and recording is disabled (fallbackMode: ${fallbackMode})`);
+    this.options.logger.log({
+      url: req.url,
+      headers: req.headers
+    });
+    if (fallbackMode === FallbackMode.PROXY) {
+      if (this.errorRate.shouldSimulate(req, void 0)) {
+        return this.errorRate.simulate(req);
+      }
+      await this.latency.simulate(req, void 0);
+      return await this.makeRealRequest(req);
+    }
+    return {
+      status: 404,
+      headers: { "content-type": ["text/plain"] },
+      body: Buffer.from("talkback - tape not found")
+    };
+  }
+  async makeRealRequest(req) {
+    let { method, url, body } = req;
+    const headers = { ...req.headers };
+    delete headers.host;
+    const host = this.options.host;
+    let urlToGetData = `${host}${url}`;
+    var fRes = {
+      status: 400,
+      headers: {},
+      body: new Buffer("")
+    };
+    try {
+      const r = await axios({
+        url: urlToGetData,
+        method,
+        headers,
+        data: body,
+        responseType: "arraybuffer"
+      });
+      fRes = {
+        status: r.status,
+        headers: r.headers,
+        body: r.data
+      };
+    } catch (err) {
+      fRes = {
+        status: err?.response?.status,
+        headers: err?.response?.headers,
+        body: err?.response?.data
+      };
     }
+    return fRes;
+  }
 }
-exports.default = RequestHandler;
-//# sourceMappingURL=request-handler.backend.js.map
+export {
+  RequestHandler as default
+};