ng-talkback 21.0.16 → 21.0.18

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

@@ -0,0 +1,94 @@
+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 * as bufferShim from 'buffer-shims';
+// const bufferShim = require('buffer-shims')/
+export default class TapeRenderer {
+    constructor(tape) {
+        this.tape = tape;
+    }
+    static async fromStore(raw, 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, reqResObj, rawBody, metaPrefix) {
+        const contentEncoding = new ContentEncoding(reqResObj);
+        const isTapeUncompressed = tape.meta[metaPrefix + "Uncompressed"];
+        const isTapeHumanReadable = tape.meta[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, metaPrefix) {
+        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[metaPrefix + "HumanReadable"] = true;
+            let body = reqResObj.body;
+            if (!isUncompressed) {
+                this.tape.meta[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.js

@@ -0,0 +1,92 @@
+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 {
+    constructor(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) {
+        const items = fse.readdirSync(directory);
+        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) {
+        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.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) {
+        return this.tapes.some(t => t.used && t.path === tapeName);
+    }
+    resetTapeUsage() {
+        return this.tapes.forEach(t => t.used = false);
+    }
+    createTapePath(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;
+    }
+}

package/lib-prod/tape.backend.js

@@ -0,0 +1,69 @@
+import MediaType from './utils/media-type.backend';
+import TapeRenderer from './tape-renderer.backend';
+import ContentEncoding from './utils/content-encoding.backend';
+import * as URL from 'url';
+import * as querystring from 'querystring';
+// const URL = require('url')
+// const querystring = require('querystring')
+export class Tape {
+    constructor(req, options) {
+        this.new = false;
+        this.used = false;
+        this.req = { ...req };
+        this.options = options;
+        // This needs to happen before we erase headers since we could lose information
+        this.normalizeBody();
+        this.cleanupHeaders();
+        this.queryParamsToIgnore = this.options.ignoreQueryParams;
+        this.cleanupQueryParams();
+        this.meta = {
+            createdAt: new Date(),
+            host: this.options.host
+        };
+    }
+    static async fromStore(raw, options) {
+        return TapeRenderer.fromStore(raw, options);
+    }
+    cleanupHeaders() {
+        const newHeaders = { ...this.req.headers };
+        this.options.ignoreHeaders.forEach(h => delete newHeaders[h]);
+        this.req = {
+            ...this.req,
+            headers: newHeaders
+        };
+    }
+    cleanupQueryParams() {
+        if (this.queryParamsToIgnore.length === 0) {
+            return;
+        }
+        const url = URL.parse(this.req.url, true);
+        if (!url.search) {
+            return;
+        }
+        const query = { ...url.query };
+        this.queryParamsToIgnore.forEach(q => delete query[q]);
+        const newQuery = querystring.stringify(query);
+        if (newQuery) {
+            url.query = query;
+            url.search = "?" + newQuery;
+        }
+        else {
+            url.query = null;
+            url.search = null;
+        }
+        this.req.url = URL.format(url);
+    }
+    normalizeBody() {
+        const mediaType = new MediaType(this.req);
+        const contentEncoding = new ContentEncoding(this.req);
+        if (contentEncoding.isUncompressed() && mediaType.isJSON() && this.req.body.length > 0) {
+            this.req.body = Buffer.from(JSON.stringify(JSON.parse(this.req.body.toString()), null, 2));
+        }
+    }
+    async clone() {
+        const tapeRenderer = new TapeRenderer(this);
+        const raw = await tapeRenderer.render();
+        return Tape.fromStore(raw, this.options);
+    }
+}
+export default Tape;

package/lib-prod/types.backend.js

@@ -0,0 +1 @@
+export {};

package/lib-prod/utils/content-encoding.backend.js

@@ -0,0 +1,36 @@
+const zlib = require('zlib');
+import Headers from './headers.backend';
+const ALGORITHMS = {
+    gzip: { compress: zlib.gzipSync, uncompress: zlib.gunzipSync },
+    deflate: { compress: zlib.deflateSync, uncompress: zlib.inflateSync }
+};
+export default class ContentEncoding {
+    constructor(reqRes) {
+        this.reqRes = reqRes;
+    }
+    isUncompressed() {
+        const contentEncoding = this.contentEncoding();
+        return !contentEncoding || contentEncoding === "identity";
+    }
+    supportedAlgorithm() {
+        const contentEncoding = this.contentEncoding();
+        return Object.keys(ALGORITHMS).includes(contentEncoding);
+    }
+    contentEncoding() {
+        return Headers.read(this.reqRes.headers, "content-encoding");
+    }
+    async uncompressedBody(body) {
+        const contentEncoding = this.contentEncoding();
+        if (!this.supportedAlgorithm()) {
+            throw new Error(`Unsupported content-encoding ${contentEncoding}`);
+        }
+        return ALGORITHMS[contentEncoding].uncompress(body);
+    }
+    async compressedBody(body) {
+        const contentEncoding = this.contentEncoding();
+        if (!this.supportedAlgorithm()) {
+            throw new Error(`Unsupported content-encoding ${contentEncoding}`);
+        }
+        return ALGORITHMS[contentEncoding].compress(body);
+    }
+}

package/lib-prod/utils/headers.backend.js

@@ -0,0 +1,14 @@
+export default class Headers {
+    static read(headers, headerName) {
+        const value = headers[headerName];
+        if (Array.isArray(value)) {
+            return value[0];
+        }
+        else {
+            return value;
+        }
+    }
+    static write(headers, headerName, value, type) {
+        headers[headerName] = type === "req" ? value : [value];
+    }
+}

package/lib-prod/utils/media-type.backend.js

@@ -0,0 +1,49 @@
+import { ___NS__merge } from 'tnp-core/lib-prod';
+import Headers from './headers.backend';
+const contentTypeParser = require('content-type');
+const equals = (to) => (contentType) => to == contentType;
+export const jsonTypes = [
+    equals("application/json"),
+    (contentType) => contentType.startsWith("application/") && contentType.endsWith("+json")
+];
+const humanReadableContentTypes = [
+    equals("application/javascript"),
+    equals("text/css"),
+    equals("text/html"),
+    equals("text/javascript"),
+    equals("text/plain"),
+    ...jsonTypes
+];
+export default class MediaType {
+    constructor(htmlReqRes) {
+        this.htmlReqRes = htmlReqRes;
+    }
+    isHumanReadable() {
+        const contentType = this.contentType();
+        if (!contentType) {
+            return false;
+        }
+        return humanReadableContentTypes.some(comparator => comparator(contentType));
+    }
+    isJSON() {
+        const contentType = this.contentType();
+        if (!contentType) {
+            return false;
+        }
+        const result = jsonTypes.some(comparator => comparator('application/json'));
+        return result;
+    }
+    contentType() {
+        const contentTypeHeader = Headers.read(this.headers(), "content-type");
+        if (!contentTypeHeader) {
+            return null;
+        }
+        const parsedContentType = contentTypeParser.parse(contentTypeHeader);
+        return parsedContentType.type;
+    }
+    headers() {
+        return ___NS__merge(this.htmlReqRes.headers, {
+            'content-type': 'application/json'
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback",
-  "version": "21.0.16",
+  "version": "21.0.18",
   "scripts": {
     "build": "node tools/build.js",
     "ci": "yarn ts-check && yarn test && yarn build && USE_DIST=1 yarn test",

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback/websql",
-  "version": "21.0.16",
+  "version": "21.0.18",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/websql-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback/websql-prod",
-  "version": "21.0.16",
+  "version": "21.0.18",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib-prod/es6.backend.ts

@@ -1,3 +0,0 @@
-import talkbackFn from './index'
-
-export default talkbackFn

package/lib-prod/features/error-rate.backend.ts

@@ -1,31 +0,0 @@
-import OptionsFactory, {Options} from '../options.backend';
-import Tape from '../tape.backend';
-import {Req, Res} from '../types.backend';
-
-export default class ErrorRate {
-  private options: Options
-
-  constructor(options: Options) {
-    this.options = options
-  }
-
-  shouldSimulate(req:Req, tape?: Tape) {
-    const globalErrorRate = typeof (this.options.errorRate) === 'number' ? this.options.errorRate : this.options.errorRate(req)
-
-    const errorRate = tape && tape.meta.errorRate !== undefined ? tape.meta.errorRate : globalErrorRate
-
-    OptionsFactory.validateErrorRate(errorRate)
-
-    const random = Math.random() * 100
-    return random < errorRate
-  }
-
-  simulate(req: Req) {
-    this.options.logger.log(`Simulating error for ${req.url}`)
-    return {
-      status: 503,
-      headers: {'content-type': ['text/plain']},
-      body: Buffer.from("talkback - failure injection")
-    } as Res
-  }
-}

package/lib-prod/features/latency.backend.ts

@@ -1,38 +0,0 @@
-import OptionsFactory, {Options} from '../options.backend';
-import {Req} from '../types.backend';
-import Tape from '../tape.backend';
-
-export default class Latency {
-  private options
-    : Options
-
-  constructor(options: Options) {
-    this.options = options
-  }
-
-  async simulate(req: Req, tape?: Tape) {
-    const resolved = Promise.resolve()
-
-    const latencyGenerator = tape && tape.meta.latency !== undefined ? tape.meta.latency : this.options.latency
-    if (!latencyGenerator) {
-      return resolved
-    }
-
-    OptionsFactory.validateLatency(latencyGenerator)
-
-    let latency = 0
-
-    const type = typeof latencyGenerator
-    if (type === "number") {
-      latency = latencyGenerator as number
-    } else if (Array.isArray(latencyGenerator)) {
-      const high = latencyGenerator[1]
-      const low = latencyGenerator[0]
-      latency = Math.random() * (high - low) + low
-    } else {
-      latency = (latencyGenerator as (_: Req) => number)(req)
-    }
-
-    return new Promise(r => setTimeout(r, latency))
-  }
-}

package/lib-prod/index.ts

@@ -1,27 +0,0 @@
-export type Dummy = 'a';
-let a = 2;
-a++;
-//#region @backend
-export * from './options.backend';
-export * from './tape.backend';
-
-
-import TalkbackFactory from './talkback-factory.backend'
-import Options, { DefaultOptions, FallbackMode, RecordMode } from './options.backend'
-
-
-const talkbackFn = (options: Partial<Options>) => {
-  return TalkbackFactory.server(options)
-}
-
-talkbackFn.Options = {
-  Default: DefaultOptions,
-  FallbackMode,
-  RecordMode
-}
-
-talkbackFn.requestHandler = (options: Partial<Options>) => TalkbackFactory.requestHandler(options)
-
-export const talkback = talkbackFn;
-export default talkbackFn;
-//#endregion

package/lib-prod/lib-info.md

@@ -1,8 +0,0 @@
-THIS FILE IS GENERATED - DO NOT MODIFY
-
-This folder is an entry point for npm Angular/NodeJS library
-
-DON'T USE STUFF FROM PARENT FOLDER app.* FILES HERE (except src/migrations/** files).
-
-THIS FILE IS GENERATED - DO NOT MODIFY
-          

package/lib-prod/logger.backend.ts

@@ -1,26 +0,0 @@
-export default class Logger {
-  options: any;
-
-  constructor(options: any) {
-    this.options = options;
-    if(this.options.debug) {
-      console.debug("DEBUG mode active")
-    }
-  }
-
-  log(message: any) {
-    if(!this.options.silent || this.options.debug) {
-      console.log(message)
-    }
-  }
-
-  debug(message: any) {
-    if(this.options.debug) {
-      console.debug(message)
-    }
-  }
-
-  error(message: any) {
-    console.error(message)
-  }
-}

package/lib-prod/migrations/index.ts

@@ -1,2 +0,0 @@
-//@ts-nocheck
-export * from './migrations_index._auto-generated_';

package/lib-prod/migrations/migrations-info.md

@@ -1,6 +0,0 @@
-THIS FILE IS GENERATED - DO NOT MODIFY
-
-This folder is only for storing migration files with auto-generated names.
-
-THIS FILE IS GENERATED - DO NOT MODIFY
-          

package/lib-prod/options.backend.ts

@@ -1,140 +0,0 @@
-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}]`
-    }
-  }
-}