ng-talkback 21.0.16 → 21.0.17

package/lib-prod/server.backend.js

@@ -0,0 +1,82 @@
+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;
+    }
+    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();
+    }
+  }
+}
+export {
+  TalkbackServer as default
+};

package/lib-prod/summary.backend.js

@@ -0,0 +1,24 @@
+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}`));
+    }
+    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

@@ -0,0 +1,19 @@
+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);
+  }
+}
+export {
+  TalkbackFactory as default
+};

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

@@ -0,0 +1,95 @@
+import ContentEncoding from "./utils/content-encoding.backend";
+import MediaType from "./utils/media-type.backend";
+import { ___NS__isEqual } from "tnp-core/lib-prod";
+class TapeMatcher {
+  tape;
+  options;
+  constructor(tape, options) {
+    this.tape = tape;
+    this.options = options;
+  }
+  sameAs(otherTape) {
+    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);
+  }
+  isSameBody(req, otherReq) {
+    const mediaType = new MediaType(req);
+    const contentEncoding = new ContentEncoding(req);
+    let sameBody;
+    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;
+  }
+  isSameHeaders(req, otherReq) {
+    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;
+  }
+  isSameMethod(req, otherReq) {
+    const sameMethod = req.method === otherReq.method;
+    if (!sameMethod) {
+      this.options.logger.debug(`Not same METHOD ${req.method} vs ${otherReq.method}`);
+      return false;
+    }
+    return true;
+  }
+  isSameUrl(req, otherReq) {
+    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;
+  }
+}
+export {
+  TapeMatcher as default
+};

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

@@ -0,0 +1,93 @@
+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";
+class TapeRenderer {
+  tape;
+  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 {
+          const parsed = JSON.parse(rawBody);
+          return parsed;
+        } catch (error) {
+          return rawBody;
+        }
+      } else {
+        return rawBody;
+      }
+    } else {
+      return reqResObj.body.toString("base64");
+    }
+  }
+}
+export {
+  TapeRenderer as default
+};

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

@@ -0,0 +1,94 @@
+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";
+class TapeStore {
+  path;
+  options;
+  tapes;
+  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 {
+      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;
+  }
+}
+export {
+  TapeStore as default
+};

package/lib-prod/tape.backend.js

@@ -0,0 +1,75 @@
+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";
+class Tape {
+  req;
+  res;
+  options;
+  queryParamsToIgnore;
+  meta;
+  path;
+  new = false;
+  used = false;
+  constructor(req, options) {
+    this.req = { ...req };
+    this.options = options;
+    this.normalizeBody();
+    this.cleanupHeaders();
+    this.queryParamsToIgnore = this.options.ignoreQueryParams;
+    this.cleanupQueryParams();
+    this.meta = {
+      createdAt: /* @__PURE__ */ 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);
+  }
+}
+var tape_backend_default = Tape;
+export {
+  Tape,
+  tape_backend_default as default
+};

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

@@ -0,0 +1,40 @@
+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 }
+};
+class ContentEncoding {
+  reqRes;
+  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);
+  }
+}
+export {
+  ContentEncoding as default
+};

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

@@ -0,0 +1,16 @@
+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];
+  }
+}
+export {
+  Headers as default
+};

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

@@ -0,0 +1,54 @@
+import { ___NS__merge } from "tnp-core/lib-prod";
+import Headers from "./headers.backend";
+const contentTypeParser = require("content-type");
+const equals = (to) => (contentType) => to == contentType;
+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
+];
+class MediaType {
+  htmlReqRes;
+  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"
+    });
+  }
+}
+export {
+  MediaType as default,
+  jsonTypes
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback",
-  "version": "21.0.16",
+  "version": "21.0.17",
   "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.17",
   "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.17",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib-prod/build-info._auto-generated_.ts

@@ -1,27 +0,0 @@
-// THIS FILE IS GENERATED - DO NOT MODIFY
-/**
- *  Autogenerated by current cli tool
- */
-export const BUILD_FRAMEWORK_CLI_NAME = 'tnp';
-/**
- *  This value can be change in taon.jsonc (appId)
- */
-export const APP_ID = 'com.domain.example.ng-talkback';
-/**
- *  Autogenerated by current cli tool
- */
-export const BUILD_BASE_HREF = '';
-/**
- *  This value can be change in taon.jsonc (overrideNpmName)
- */
-export const PROJECT_NPM_NAME = 'ng-talkback';
-/**
- * Taon version from you project taon.json
- */
-export const CURRENT_PACKAGE_TAON_VERSION = 'v21';
-/**
- *  Autogenerated by current cli tool. Use *tnp release* to bump version.
- */
-export const CURRENT_PACKAGE_VERSION = '21.0.16';
-// THIS FILE IS GENERATED - DO NOT MODIFY
-