ng-talkback 21.0.16 → 21.0.18

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

@@ -1,165 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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")
-    }
-  }
-
-}

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

@@ -1,111 +0,0 @@
-import { Options } from './options.backend';
-import { fse, path, json5, mkdirp } from 'tnp-core/lib-prod';
-
-import Tape from './tape.backend';
-import TapeMatcher from './tape-matcher.backend';
-import TapeRenderer from './tape-renderer.backend';
-
-export default class TapeStore {
-  private readonly path: string
-  private readonly options: Options
-  tapes: Tape[]
-
-  constructor(options: Options) {
-    this.path = path.normalize(options.path + "/")
-    this.options = options
-    this.tapes = []
-  }
-
-  async load() {
-    mkdirp.sync(this.path)
-
-    await this.loadTapesAtDir(this.path)
-    console.log(`Loaded ${this.tapes.length} tapes`)
-  }
-
-  async loadTapesAtDir(directory: string) {
-    const items = fse.readdirSync(directory) as string[]
-    for (let i = 0; i < items.length; i++) {
-      const filename = items[i]
-      const fullPath = `${directory}${filename}`
-      const stat = fse.statSync(fullPath)
-      if (!stat.isDirectory()) {
-        try {
-          const data = fse.readFileSync(fullPath, "utf8")
-          const raw = json5.parse(data)
-          const tape = await Tape.fromStore(raw, this.options)
-          tape.path = filename
-          this.tapes.push(tape)
-        } catch (e) {
-          console.log(`Error reading tape ${fullPath}`, e.message)
-        }
-      } else {
-        this.loadTapesAtDir(fullPath + "/")
-      }
-    }
-  }
-
-  find(newTape: Tape) {
-    const foundTape = this.tapes.find(t => {
-      this.options.logger.debug(`Comparing against tape ${t.path}`)
-      return new TapeMatcher(t, this.options).sameAs(newTape)
-    })
-
-    if (foundTape) {
-      foundTape.used = true
-      this.options.logger.log(`Found matching tape for ${newTape.req.url} at ${foundTape.path}`)
-      return foundTape
-    }
-  }
-
-  async save(tape: Tape) {
-    tape.new = true
-    tape.used = true
-
-    const tapePath = tape.path
-    let fullFilename
-
-    if (tapePath) {
-      fullFilename = path.join(this.path, tapePath)
-    } else {
-      // If the tape doesn't have a path then it's new
-      this.tapes.push(tape)
-
-      fullFilename = this.createTapePath(tape)
-      tape.path = path.relative(this.path, fullFilename)
-    }
-    this.options.logger.log(`Saving request ${tape.req.url} at ${tape.path}`)
-
-    const tapeRenderer = new TapeRenderer(tape)
-    const toSave = await tapeRenderer.render()
-    fse.writeFileSync(fullFilename, json5.stringify(toSave, null, 4))
-  }
-
-  currentTapeId() {
-    return this.tapes.length
-  }
-
-  hasTapeBeenUsed(tapeName: string) {
-    return this.tapes.some(t => t.used && t.path === tapeName)
-  }
-
-  resetTapeUsage() {
-    return this.tapes.forEach(t => t.used = false)
-  }
-
-  createTapePath(tape: Tape) {
-    const currentTapeId = this.currentTapeId()
-    let tapePath = `unnamed-${currentTapeId}.json5`
-    if (this.options.tapeNameGenerator) {
-      tapePath = this.options.tapeNameGenerator(currentTapeId, tape)
-    }
-    let result = path.normalize(path.join(this.options.path, tapePath))
-    if (!result.endsWith(".json5")) {
-      result = `${result}.json5`
-    }
-    const dir = path.dirname(result)
-    mkdirp.sync(dir)
-
-    return result
-  }
-}