ng-talkback 21.0.17 → 21.0.19

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

@@ -1,131 +1,137 @@
-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 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");
-      }
+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';
+export default class RequestHandler {
+    constructor(tapeStore, options) {
+        this.tapeStore = tapeStore;
+        this.options = options;
+        this.errorRate = new ErrorRate(this.options);
+        this.latency = new Latency(this.options);
     }
-    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");
-          }
+    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");
+            }
         }
-        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;
+        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");
+                    }
+                }
+                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;
     }
-    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);
+    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, 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")
+        };
     }
-    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
-      };
+    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 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;
     }
-    return fRes;
-  }
 }
-export {
-  RequestHandler as default
-};

package/lib-prod/server.backend.js

@@ -1,82 +1,79 @@
-import RequestHandler from "./request-handler.backend";
-import Summary from "./summary.backend";
-import TapeStore from "./tape-store.backend";
-import * as http from "http";
-import { https, fse } from "tnp-core/lib-prod";
-class TalkbackServer {
-  options;
-  tapeStore;
-  requestHandler;
-  closeSignalHandler;
-  server;
-  closed = false;
-  constructor(options) {
-    this.options = options;
-    this.tapeStore = new TapeStore(this.options);
-    this.requestHandler = new RequestHandler(this.tapeStore, this.options);
-    this.closeSignalHandler = this.close.bind(this);
-  }
-  handleRequest(rawReq, res) {
-    let reqBody = [];
-    rawReq.on("data", (chunk) => {
-      reqBody.push(chunk);
-    }).on("end", async () => {
-      try {
-        const req = {
-          headers: rawReq.headers,
-          url: rawReq.url,
-          method: rawReq.method,
-          body: Buffer.concat(reqBody)
-        };
-        const fRes = await this.requestHandler.handle(req);
-        res.writeHead(fRes.status, fRes.headers);
-        res.end(fRes.body);
-      } catch (ex) {
-        console.error("Error handling request", ex);
-        res.statusCode = 500;
-        res.end();
-      }
-    });
-  }
-  async start(callback) {
-    await this.tapeStore.load();
-    const handleRequest = this.handleRequest.bind(this);
-    const serverFactory = this.options.https.enabled ? () => {
-      const httpsOpts = {
-        key: fse.readFileSync(this.options.https.keyPath),
-        cert: fse.readFileSync(this.options.https.certPath)
-      };
-      return https.createServer(httpsOpts, handleRequest);
-    } : () => http.createServer(handleRequest);
-    this.server = serverFactory();
-    console.log(`Starting talkback on ${this.options.port}`);
-    this.server.listen(this.options.port, callback);
-    process.on("exit", this.closeSignalHandler);
-    process.on("SIGINT", this.closeSignalHandler);
-    process.on("SIGTERM", this.closeSignalHandler);
-    return this.server;
-  }
-  hasTapeBeenUsed(tapeName) {
-    return this.tapeStore.hasTapeBeenUsed(tapeName);
-  }
-  resetTapeUsage() {
-    this.tapeStore.resetTapeUsage();
-  }
-  close(callback) {
-    if (this.closed) {
-      return;
+import RequestHandler from './request-handler.backend';
+import Summary from './summary.backend';
+import TapeStore from './tape-store.backend';
+import * as http from 'http';
+import { https, fse } from 'tnp-core/lib-prod';
+export default class TalkbackServer {
+    constructor(options) {
+        this.closed = false;
+        this.options = options;
+        this.tapeStore = new TapeStore(this.options);
+        this.requestHandler = new RequestHandler(this.tapeStore, this.options);
+        this.closeSignalHandler = this.close.bind(this);
     }
-    this.closed = true;
-    this.server.close(callback);
-    process.removeListener("exit", this.closeSignalHandler);
-    process.removeListener("SIGINT", this.closeSignalHandler);
-    process.removeListener("SIGTERM", this.closeSignalHandler);
-    if (this.options.summary) {
-      const summary = new Summary(this.tapeStore.tapes, this.options);
-      summary.print();
+    handleRequest(rawReq, res) {
+        // console.log(`rawReq: ${rawReq.url}`)
+        let reqBody = [];
+        rawReq.on("data", (chunk) => {
+            reqBody.push(chunk);
+        }).on("end", async () => {
+            try {
+                const req = {
+                    headers: rawReq.headers,
+                    url: rawReq.url,
+                    method: rawReq.method,
+                    body: Buffer.concat(reqBody)
+                };
+                const fRes = await this.requestHandler.handle(req);
+                res.writeHead(fRes.status, fRes.headers);
+                res.end(fRes.body);
+            }
+            catch (ex) {
+                console.error("Error handling request", ex);
+                res.statusCode = 500;
+                res.end();
+            }
+        });
+    }
+    async start(callback) {
+        await this.tapeStore.load();
+        const handleRequest = this.handleRequest.bind(this);
+        const serverFactory = this.options.https.enabled ? () => {
+            const httpsOpts = {
+                key: fse.readFileSync(this.options.https.keyPath),
+                cert: fse.readFileSync(this.options.https.certPath)
+            };
+            return https.createServer(httpsOpts, handleRequest);
+        } : () => http.createServer(handleRequest);
+        this.server = serverFactory();
+        console.log(`Starting talkback on ${this.options.port}`);
+        this.server.listen(this.options.port, callback);
+        process.on("exit", this.closeSignalHandler);
+        process.on("SIGINT", this.closeSignalHandler);
+        process.on("SIGTERM", this.closeSignalHandler);
+        return this.server;
+    }
+    hasTapeBeenUsed(tapeName) {
+        return this.tapeStore.hasTapeBeenUsed(tapeName);
+    }
+    resetTapeUsage() {
+        this.tapeStore.resetTapeUsage();
+    }
+    close(callback) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.server.close(callback);
+        // @ts-ignore
+        process.removeListener("exit", this.closeSignalHandler);
+        // @ts-ignore
+        process.removeListener("SIGINT", this.closeSignalHandler);
+        // @ts-ignore
+        process.removeListener("SIGTERM", this.closeSignalHandler);
+        if (this.options.summary) {
+            const summary = new Summary(this.tapeStore.tapes, this.options);
+            summary.print();
+        }
     }
-  }
 }
-export {
-  TalkbackServer as default
-};

package/lib-prod/summary.backend.js

@@ -1,24 +1,19 @@
-class Summary {
-  tapes;
-  opts;
-  constructor(tapes, opts) {
-    this.tapes = tapes;
-    this.opts = opts;
-  }
-  print() {
-    console.log(`===== SUMMARY (${this.opts.name}) =====`);
-    const newTapes = this.tapes.filter((t) => t.new);
-    if (newTapes.length > 0) {
-      console.log("New tapes:");
-      newTapes.forEach((t) => console.log(`- ${t.path}`));
+export default class Summary {
+    constructor(tapes, opts) {
+        this.tapes = tapes;
+        this.opts = opts;
     }
-    const unusedTapes = this.tapes.filter((t) => !t.used);
-    if (unusedTapes.length > 0) {
-      console.log("Unused tapes:");
-      unusedTapes.forEach((t) => console.log(`- ${t.path}`));
+    print() {
+        console.log(`===== SUMMARY (${this.opts.name}) =====`);
+        const newTapes = this.tapes.filter(t => t.new);
+        if (newTapes.length > 0) {
+            console.log("New tapes:");
+            newTapes.forEach(t => console.log(`- ${t.path}`));
+        }
+        const unusedTapes = this.tapes.filter(t => !t.used);
+        if (unusedTapes.length > 0) {
+            console.log("Unused tapes:");
+            unusedTapes.forEach(t => console.log(`- ${t.path}`));
+        }
     }
-  }
 }
-export {
-  Summary as default
-};

package/lib-prod/talkback-factory.backend.js

@@ -1,19 +1,16 @@
-import Options from "./options.backend";
-import TapeStore from "./tape-store.backend";
-import TalkbackServer from "./server.backend";
-import RequestHandler from "./request-handler.backend";
-class TalkbackFactory {
-  static server(options) {
-    const fullOptions = Options.prepare(options);
-    return new TalkbackServer(fullOptions);
-  }
-  static async requestHandler(options) {
-    const fullOptions = Options.prepare(options);
-    const tapeStore = new TapeStore(fullOptions);
-    await tapeStore.load();
-    return new RequestHandler(tapeStore, fullOptions);
-  }
+import Options from './options.backend';
+import TapeStore from './tape-store.backend';
+import TalkbackServer from './server.backend';
+import RequestHandler from './request-handler.backend';
+export default class TalkbackFactory {
+    static server(options) {
+        const fullOptions = Options.prepare(options);
+        return new TalkbackServer(fullOptions);
+    }
+    static async requestHandler(options) {
+        const fullOptions = Options.prepare(options);
+        const tapeStore = new TapeStore(fullOptions);
+        await tapeStore.load();
+        return new RequestHandler(tapeStore, fullOptions);
+    }
 }
-export {
-  TalkbackFactory as default
-};