ng-talkback 21.0.14 → 21.0.16

package/lib-prod/options.backend.ts

@@ -0,0 +1,140 @@
+import Logger from './logger.backend';
+import Tape from './tape.backend';
+import {Req, MatchingContext} from './types.backend';
+
+export 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: [] as string[]
+}
+RecordMode.ALL = [RecordMode.NEW, RecordMode.OVERWRITE, RecordMode.DISABLED]
+
+export const FallbackMode = {
+  NOT_FOUND: "NOT_FOUND",
+  PROXY: "PROXY",
+  ALL: [] as string[]
+}
+FallbackMode.ALL = [FallbackMode.NOT_FOUND, FallbackMode.PROXY]
+
+export interface Options {
+  host: string,
+  port: number,
+  path: string,
+  record: string | ((req: Req) => string),
+  fallbackMode: string | ((req: Req) => string),
+  name: string,
+  tapeNameGenerator?: (tapeNumber: number, tape: Tape) => string,
+  https: {
+    enabled: boolean,
+    keyPath?: string,
+    certPath?: string
+  },
+  ignoreHeaders: string[],
+  ignoreQueryParams: string[],
+  ignoreBody: boolean,
+
+  bodyMatcher?: (tape: Tape, req: Req) => boolean,
+  urlMatcher?: (tape: Tape, req: Req) => boolean,
+
+  requestDecorator?: (req: Req, context: MatchingContext) => Req,
+  responseDecorator?: (tape: Tape, req: Req, context: MatchingContext) => Tape,
+  tapeDecorator?: (tape: Tape, context: MatchingContext) => Tape,
+
+  latency: number | number[] | ((req: Req) => number),
+  errorRate: number | ((req: Req) => number),
+
+  silent: boolean,
+  summary: boolean,
+  debug: boolean,
+  logger: Logger
+}
+
+export const DefaultOptions: Options = {
+  host: "",
+  port: 8080,
+  path: "./tapes/",
+  record: RecordMode.NEW,
+  fallbackMode: 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({})
+}
+
+export default class OptionsFactory {
+  private static logger: Logger
+
+  static prepare(usrOpts: Partial<Options> = {}) {
+    const opts: typeof DefaultOptions = {
+      ...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: Options) {
+    this.validateRecord(opts.record)
+    this.validateFallbackMode(opts.fallbackMode)
+    this.validateLatency(opts.latency)
+    this.validateErrorRate(opts.errorRate)
+  }
+
+  static validateRecord(record: any) {
+    if (typeof (record) === "string" && !RecordMode.ALL.includes(record)) {
+      throw `INVALID OPTION: record has an invalid value of '${record}'`
+    }
+  }
+
+  static validateFallbackMode(fallbackMode: any) {
+    if (typeof (fallbackMode) === "string" && !FallbackMode.ALL.includes(fallbackMode)) {
+      throw `INVALID OPTION: fallbackMode has an invalid value of '${fallbackMode}'`
+    }
+  }
+
+  static validateLatency(latency: any) {
+    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: any) {
+    if (typeof (errorRate) !== "function" && (errorRate < 0 || errorRate > 100)) {
+      throw `Invalid ERRORRATE option. Value should be between 0 and 100. Current=[${errorRate}]`
+    }
+  }
+}

package/lib-prod/package.json

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

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

@@ -0,0 +1,165 @@
+import TapeStore from './tape-store.backend';
+import { v4 as uuidv4 } from 'uuid';
+
+import axios, { AxiosResponse } from 'axios';
+
+import Tape from './tape.backend';
+import OptionsFactory, { RecordMode, FallbackMode, Options } from './options.backend';
+import ErrorRate from './features/error-rate.backend';
+import Latency from './features/latency.backend';
+import { HttpRequest, HttpResponse, MatchingContext } from './types.backend';
+
+export default class RequestHandler {
+  private readonly tapeStore: TapeStore
+  private readonly options: Options
+  private readonly errorRate: ErrorRate
+  private readonly latency: Latency
+
+  constructor(tapeStore: TapeStore, options: Options) {
+    this.tapeStore = tapeStore
+    this.options = options
+    this.errorRate = new ErrorRate(this.options)
+    this.latency = new Latency(this.options)
+  }
+
+  async handle(req: HttpRequest): Promise<HttpResponse> {
+    const matchingContext: 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")
+      }
+    }
+
+    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
+  }
+
+  private async onNoRecord(req: HttpRequest) {
+    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")
+    } as HttpResponse
+  }
+
+  private async makeRealRequest(req: HttpRequest) {
+    // 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('')
+    } as any;
+    try {
+      // console.log(body.toString())
+      const r = await axios({
+        url: urlToGetData,
+        method,
+        headers,
+        data: body,
+        responseType: 'arraybuffer',
+      }) as any;
+      fRes = {
+        status: r.status,
+        headers: r.headers,
+        body: r.data
+      } as HttpResponse;
+    } catch (err) {
+      fRes = {
+        status: err?.response?.status,
+        headers: err?.response?.headers,
+        body: err?.response?.data
+      } as any;
+    }
+    return fRes;
+  }
+}

package/lib-prod/server.backend.ts

@@ -0,0 +1,100 @@
+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';
+import { Options } from './options.backend';
+import { Req } from './types.backend';
+
+export default class TalkbackServer {
+  private readonly options: Options
+  readonly tapeStore: TapeStore
+  private requestHandler: RequestHandler
+  private readonly closeSignalHandler?: (...args: any[]) => void
+  private server?: http.Server
+  private closed: boolean = false
+
+  constructor(options: 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: http.IncomingMessage, res: http.ServerResponse) {
+    // console.log(`rawReq: ${rawReq.url}`)
+    let reqBody = [] as Uint8Array[]
+    rawReq.on("data", (chunk) => {
+      reqBody.push(chunk)
+    }).on("end", async () => {
+      try {
+        const req: 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?: () => void) {
+    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 as any)
+    process.on("SIGINT", this.closeSignalHandler as any)
+    process.on("SIGTERM", this.closeSignalHandler as any)
+
+    return this.server
+  }
+
+  hasTapeBeenUsed(tapeName: string) {
+    return this.tapeStore.hasTapeBeenUsed(tapeName)
+  }
+
+  resetTapeUsage() {
+    this.tapeStore.resetTapeUsage()
+  }
+
+  close(callback?: () => void) {
+    if (this.closed) {
+      return
+    }
+    this.closed = true
+    this.server!.close(callback)
+
+    // @ts-ignore
+    process.removeListener("exit", this.closeSignalHandler as any)
+    // @ts-ignore
+    process.removeListener("SIGINT", this.closeSignalHandler as any)
+    // @ts-ignore
+    process.removeListener("SIGTERM", this.closeSignalHandler as any)
+
+    if (this.options.summary) {
+      const summary = new Summary(this.tapeStore.tapes, this.options)
+      summary.print()
+    }
+  }
+}

package/lib-prod/summary.backend.ts

@@ -0,0 +1,26 @@
+import Tape from './tape.backend';
+import {Options} from './options.backend';
+
+export default class Summary {
+  private tapes: Tape[]
+  private opts: Options
+
+  constructor(tapes: Tape[], opts: Options) {
+    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}`))
+    }
+    const unusedTapes = this.tapes.filter(t => !t.used)
+    if (unusedTapes.length > 0) {
+      console.log("Unused tapes:")
+      unusedTapes.forEach(t => console.log(`- ${t.path}`))
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+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: Partial<Options>) {
+    const fullOptions = Options.prepare(options)
+    return new TalkbackServer(fullOptions)
+  }
+
+  static async requestHandler(options: Partial<Options>) {
+    const fullOptions = Options.prepare(options)
+    const tapeStore = new TapeStore(fullOptions)
+    await tapeStore.load()
+    return new RequestHandler(tapeStore, fullOptions)
+  }
+}

package/lib-prod/tape-matcher.backend.ts

@@ -0,0 +1,113 @@
+import ContentEncoding from './utils/content-encoding.backend';
+import MediaType from './utils/media-type.backend';
+import { Options } from './options.backend';
+import Tape from './tape.backend';
+import { Req } from './types.backend';
+import { ___NS__add, ___NS__after, ___NS__ary, ___NS__assign, ___NS__assignIn, ___NS__assignInWith, ___NS__assignWith, ___NS__at, ___NS__attempt, ___NS__before, ___NS__bind, ___NS__bindAll, ___NS__bindKey, ___NS__camelCase, ___NS__capitalize, ___NS__castArray, ___NS__ceil, ___NS__chain, ___NS__chunk, ___NS__clamp, ___NS__clone, ___NS__cloneDeep, ___NS__cloneDeepWith, ___NS__cloneWith, ___NS__compact, ___NS__concat, ___NS__cond, ___NS__conforms, ___NS__conformsTo, ___NS__constant, ___NS__countBy, ___NS__create, ___NS__curry, ___NS__curryRight, ___NS__debounce, ___NS__deburr, ___NS__defaults, ___NS__defaultsDeep, ___NS__defaultTo, ___NS__defer, ___NS__delay, ___NS__difference, ___NS__differenceBy, ___NS__differenceWith, ___NS__divide, ___NS__drop, ___NS__dropRight, ___NS__dropRightWhile, ___NS__dropWhile, ___NS__each, ___NS__eachRight, ___NS__endsWith, ___NS__entries, ___NS__entriesIn, ___NS__eq, ___NS__escape, ___NS__escapeRegExp, ___NS__every, ___NS__extend, ___NS__extendWith, ___NS__fill, ___NS__filter, ___NS__find, ___NS__findIndex, ___NS__findKey, ___NS__findLast, ___NS__findLastIndex, ___NS__findLastKey, ___NS__first, ___NS__flatMap, ___NS__flatMapDeep, ___NS__flatMapDepth, ___NS__flatten, ___NS__flattenDeep, ___NS__flattenDepth, ___NS__flip, ___NS__floor, ___NS__flow, ___NS__flowRight, ___NS__forEach, ___NS__forEachRight, ___NS__forIn, ___NS__forInRight, ___NS__forOwn, ___NS__forOwnRight, ___NS__fromPairs, ___NS__functions, ___NS__functionsIn, ___NS__get, ___NS__groupBy, ___NS__gt, ___NS__gte, ___NS__has, ___NS__hasIn, ___NS__head, ___NS__identity, ___NS__includes, ___NS__indexOf, ___NS__initial, ___NS__inRange, ___NS__intersection, ___NS__intersectionBy, ___NS__intersectionWith, ___NS__invert, ___NS__invertBy, ___NS__invoke, ___NS__invokeMap, ___NS__isArguments, ___NS__isArray, ___NS__isArrayBuffer, ___NS__isArrayLike, ___NS__isArrayLikeObject, ___NS__isBoolean, ___NS__isBuffer, ___NS__isDate, ___NS__isElement, ___NS__isEmpty, ___NS__isEqual, ___NS__isEqualWith, ___NS__isError, ___NS__isFinite, ___NS__isFunction, ___NS__isInteger, ___NS__isLength, ___NS__isMap, ___NS__isMatch, ___NS__isMatchWith, ___NS__isNaN, ___NS__isNative, ___NS__isNil, ___NS__isNull, ___NS__isNumber, ___NS__isObject, ___NS__isObjectLike, ___NS__isPlainObject, ___NS__isRegExp, ___NS__isSafeInteger, ___NS__isSet, ___NS__isString, ___NS__isSymbol, ___NS__isTypedArray, ___NS__isUndefined, ___NS__isWeakMap, ___NS__isWeakSet, ___NS__iteratee, ___NS__join, ___NS__kebabCase, ___NS__keyBy, ___NS__keys, ___NS__keysIn, ___NS__last, ___NS__lastIndexOf, ___NS__lowerCase, ___NS__lowerFirst, ___NS__lt, ___NS__lte, ___NS__map, ___NS__mapKeys, ___NS__mapValues, ___NS__matches, ___NS__matchesProperty, ___NS__max, ___NS__maxBy, ___NS__mean, ___NS__meanBy, ___NS__memoize, ___NS__merge, ___NS__mergeWith, ___NS__method, ___NS__methodOf, ___NS__min, ___NS__minBy, ___NS__mixin, ___NS__multiply, ___NS__negate, ___NS__noop, ___NS__now, ___NS__nth, ___NS__nthArg, ___NS__omit, ___NS__omitBy, ___NS__once, ___NS__orderBy, ___NS__over, ___NS__overArgs, ___NS__overEvery, ___NS__overSome, ___NS__pad, ___NS__padEnd, ___NS__padStart, ___NS__parseInt, ___NS__partial, ___NS__partialRight, ___NS__partition, ___NS__pick, ___NS__pickBy, ___NS__property, ___NS__propertyOf, ___NS__pull, ___NS__pullAll, ___NS__pullAllBy, ___NS__pullAllWith, ___NS__pullAt, ___NS__random, ___NS__range, ___NS__rangeRight, ___NS__rearg, ___NS__reduce, ___NS__reduceRight, ___NS__reject, ___NS__remove, ___NS__repeat, ___NS__replace, ___NS__rest, ___NS__result, ___NS__reverse, ___NS__round, ___NS__sample, ___NS__sampleSize, ___NS__set, ___NS__setWith, ___NS__shuffle, ___NS__size, ___NS__slice, ___NS__snakeCase, ___NS__some, ___NS__sortBy, ___NS__sortedIndex, ___NS__sortedIndexBy, ___NS__sortedIndexOf, ___NS__sortedLastIndex, ___NS__sortedLastIndexBy, ___NS__sortedLastIndexOf, ___NS__sortedUniq, ___NS__sortedUniqBy, ___NS__split, ___NS__spread, ___NS__startCase, ___NS__startsWith, ___NS__stubArray, ___NS__stubFalse, ___NS__stubObject, ___NS__stubString, ___NS__stubTrue, ___NS__subtract, ___NS__sum, ___NS__sumBy, ___NS__tail, ___NS__take, ___NS__takeRight, ___NS__takeRightWhile, ___NS__takeWhile, ___NS__tap, ___NS__template, ___NS__templateSettings, ___NS__throttle, ___NS__thru, ___NS__times, ___NS__toArray, ___NS__toFinite, ___NS__toInteger, ___NS__toLength, ___NS__toLower, ___NS__toNumber, ___NS__toPairs, ___NS__toPairsIn, ___NS__toPath, ___NS__toPlainObject, ___NS__toSafeInteger, ___NS__toString, ___NS__toUpper, ___NS__transform, ___NS__trim, ___NS__trimEnd, ___NS__trimStart, ___NS__truncate, ___NS__unary, ___NS__unescape, ___NS__union, ___NS__unionBy, ___NS__unionWith, ___NS__uniq, ___NS__uniqBy, ___NS__uniqueId, ___NS__uniqWith, ___NS__unset, ___NS__unzip, ___NS__unzipWith, ___NS__update, ___NS__updateWith, ___NS__upperCase, ___NS__upperFirst, ___NS__values, ___NS__valuesIn, ___NS__without, ___NS__words, ___NS__wrap, ___NS__xor, ___NS__xorBy, ___NS__xorWith, ___NS__zip, ___NS__zipObject, ___NS__zipObjectDeep, ___NS__zipWith } from 'tnp-core/lib-prod';
+
+export default class TapeMatcher {
+  private readonly tape: Tape
+  private readonly options: Options
+
+  constructor(tape: Tape, options: Options) {
+    this.tape = tape
+    this.options = options
+  }
+
+  sameAs(otherTape: Tape) {
+    const otherReq = otherTape.req
+    const req = this.tape.req
+    if (!this.isSameUrl(req, otherReq)) {
+      return false
+    }
+
+    if (!this.isSameMethod(req, otherReq)) {
+      return false
+    }
+
+    if (!this.isSameHeaders(req, otherReq)) {
+      return false
+    }
+
+    return this.options.ignoreBody || this.isSameBody(req, otherReq);
+
+  }
+
+  private isSameBody(req: Req, otherReq: Req) {
+    const mediaType = new MediaType(req)
+    const contentEncoding = new ContentEncoding(req)
+
+
+    let sameBody: boolean
+    if (contentEncoding.isUncompressed() && mediaType.isJSON() && req.body.length > 0 && otherReq.body.length > 0) {
+      const parsedReqBody = JSON.parse(req.body.toString())
+      const parsedOtherReqBody = JSON.parse(otherReq.body.toString())
+      sameBody = ___NS__isEqual(parsedReqBody, parsedOtherReqBody)
+    } else {
+      sameBody = req.body.equals(otherReq.body)
+    }
+
+    if (!sameBody) {
+      if (!this.options.bodyMatcher) {
+        this.options.logger.debug(`Not same BODY ${req.body} vs ${otherReq.body}`)
+        return false
+      }
+
+      const bodyMatches = this.options.bodyMatcher(this.tape, otherReq)
+      if (!bodyMatches) {
+        this.options.logger.debug(`Not same bodyMatcher ${req.body} vs ${otherReq.body}`)
+        return false
+      }
+    }
+    return true
+  }
+
+  private isSameHeaders(req: Req, otherReq: Req) {
+    const currentHeadersLength = Object.keys(req.headers).length
+    const otherHeadersLength = Object.keys(otherReq.headers).length
+    const sameNumberOfHeaders = currentHeadersLength === otherHeadersLength
+    if (!sameNumberOfHeaders) {
+      this.options.logger.debug(`Not same #HEADERS ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`)
+      return false
+    }
+
+    let headersSame = true
+    Object.keys(req.headers).forEach(k => {
+      const entryHeader = req.headers[k]
+      const header = otherReq.headers[k]
+
+      headersSame = headersSame && entryHeader === header
+    })
+    if (!headersSame) {
+      this.options.logger.debug(`Not same HEADERS values ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`)
+      return false
+    }
+    return true
+  }
+
+  private isSameMethod(req: Req, otherReq: Req) {
+    const sameMethod = req.method === otherReq.method
+    if (!sameMethod) {
+      this.options.logger.debug(`Not same METHOD ${req.method} vs ${otherReq.method}`)
+      return false
+    }
+    return true
+  }
+
+  private isSameUrl(req: Req, otherReq: Req) {
+    const sameURL = req.url === otherReq.url
+    if (!sameURL) {
+      if (!this.options.urlMatcher) {
+        this.options.logger.debug(`Not same URL ${req.url} vs ${otherReq.url}`)
+        return false
+      }
+
+      const urlMatches = this.options.urlMatcher(this.tape, otherReq)
+      if (!urlMatches) {
+        this.options.logger.debug(`Not same urlMatcher ${req.url} vs ${otherReq.url}`)
+        return false
+      }
+    }
+    return true
+  }
+}

package/lib-prod/tape-renderer.backend.ts

@@ -0,0 +1,118 @@
+import Headers from './utils/headers.backend';
+import MediaType from './utils/media-type.backend';
+import Tape from './tape.backend';
+import ContentEncoding from './utils/content-encoding.backend';
+import { Options } from './options.backend';
+import { ReqRes } from './types.backend';
+import * as _ from 'lodash';
+import * as bufferShim from 'buffer-shims';
+// const bufferShim = require('buffer-shims')/
+
+export default class TapeRenderer {
+  private tape: Tape
+
+  constructor(tape: Tape) {
+    this.tape = tape
+  }
+
+  static async fromStore(raw: any, options: Options) {
+
+    const req = { ...raw.req }
+
+    req.body = await this.prepareBody(raw, req, req.body, "req")
+
+    const tape = new Tape(req, options)
+    tape.meta = { ...raw.meta }
+    const baseRes = { ...raw.res }
+    const resBody = await this.prepareBody(tape, baseRes, baseRes.body, "res")
+
+    tape.res = {
+      ...baseRes,
+      body: resBody
+    }
+
+    return tape
+  }
+
+  static async prepareBody(tape: Tape, reqResObj: ReqRes, rawBody: string, metaPrefix: "res" | "req") {
+    const contentEncoding = new ContentEncoding(reqResObj)
+    const isTapeUncompressed = (tape.meta as any)[metaPrefix + "Uncompressed"]
+    const isTapeHumanReadable = (tape.meta as any)[metaPrefix + "HumanReadable"]
+    const isTapeInPlainText = isTapeUncompressed || contentEncoding.isUncompressed()
+
+    if (isTapeHumanReadable && isTapeInPlainText) {
+      const mediaType = new MediaType(reqResObj)
+      let bufferContent = rawBody
+      const isResAnObject = typeof (bufferContent) === "object"
+
+      if (isResAnObject && mediaType.isJSON()) {
+        bufferContent = JSON.stringify(bufferContent, null, 2)
+      }
+
+      if (Headers.read(reqResObj.headers, "content-length")) {
+        Headers.write(reqResObj.headers, "content-length", Buffer.byteLength(bufferContent).toString(), metaPrefix)
+      }
+
+      if (isTapeUncompressed) {
+        return await contentEncoding.compressedBody(bufferContent)
+      }
+
+      return bufferShim.from(bufferContent)
+    } else {
+      return bufferShim.from(rawBody, "base64")
+    }
+  }
+
+  async render() {
+    const reqBody = await this.bodyFor(this.tape.req, "req")
+    const resBody = await this.bodyFor(this.tape.res!, "res")
+    return {
+      meta: this.tape.meta,
+      req: {
+        ...this.tape.req,
+        body: reqBody
+      },
+      res: {
+        ...this.tape.res,
+        body: resBody
+      }
+    }
+  }
+
+  async bodyFor(reqResObj: ReqRes, metaPrefix: "req" | "res") {
+    const mediaType = new MediaType(reqResObj)
+    const contentEncoding = new ContentEncoding(reqResObj)
+    const bodyLength = reqResObj.body.length
+
+
+    const isUncompressed = contentEncoding.isUncompressed()
+    const contentEncodingSupported = isUncompressed || contentEncoding.supportedAlgorithm()
+
+    if (mediaType.isHumanReadable() && contentEncodingSupported && bodyLength > 0) {
+      (this.tape.meta as any)[metaPrefix + "HumanReadable"] = true
+
+      let body = reqResObj.body
+
+      if (!isUncompressed) {
+        (this.tape.meta as any)[metaPrefix + "Uncompressed"] = true
+        body = await contentEncoding.uncompressedBody(body)
+      }
+
+      const rawBody = body.toString("utf8")
+
+      if (mediaType.isJSON()) {
+        try { // TODO handle this better in future not based on mediaType.isJSON
+          const parsed = JSON.parse(rawBody);
+          return parsed;
+        } catch (error) {
+          return rawBody;
+        }
+      } else {
+        return rawBody;
+      }
+    } else {
+      return reqResObj.body.toString("base64")
+    }
+  }
+
+}