node-avo-inspector 1.1.1 → 1.2.0

package/.claude/worktrees/release-1.1.1/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "node-avo-inspector",
+  "version": "1.1.1",
+  "description": "Avo Inspector for Node.js",
+  "main": "dist/index.js",
+  "repository": "https://github.com/avohq/node-avo-inspector",
+  "author": "Avo (https://www.avo.app)",
+  "license": "MIT",
+  "private": false,
+  "bugs": {
+    "url": "https://github.com/avohq/node-avo-inspector/issues"
+  },
+  "homepage": "https://github.com/avohq/node-avo-inspector#readme",
+  "scripts": {
+    "build": "tsc --outDir dist",
+    "test": "jest",
+    "typecheck": "tsc --noEmit"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.[j]sx?$": "babel-jest",
+      "^.+\\.[t]sx?$": "ts-jest"
+    },
+    "testPathIgnorePatterns": [
+      "constants",
+      "examples",
+      "node_modules",
+      "dist",
+      "dist-native"
+    ],
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.4",
+    "typescript": "*"
+  },
+  "dependencies": {
+    "safe-regex2": "^5.0.0"
+  }
+}

package/.claude/worktrees/release-1.1.1/reason/AvoInspector.rei

@@ -0,0 +1,11 @@
+type t; 
+
+type env = [
+  | `Dev
+  | `Staging
+  | `Prod
+];
+
+let make: (~apiKey: string, ~env: env, ~version: string, , ~appName: string, unit) => t;
+
+let trackSchemaFromEvent: t => string => Js.Json.t => Js.Promise.t(unit);

package/.claude/worktrees/release-1.1.1/reason/NodeAvoInspector.re

@@ -0,0 +1,27 @@
+type t;
+
+[@bs.deriving jsConverter]
+type env = [
+  | [@bs.as "dev"] `Dev
+  | [@bs.as "staging"] `Staging
+  | [@bs.as "prod"] `Prod
+];
+
+[@bs.deriving abstract]
+type options = {
+  apiKey: string,
+  env: string,
+  version: string,
+  appName: string,
+};
+
+[@bs.new] [@bs.module "node-avo-inspector"]
+external make: options => t = "AvoInspector";
+
+let make = (~apiKey, ~env, ~version, ~appName, ()) => {
+  make(options(~apiKey, ~env=envToJs(env), ~version, ~appName));
+};
+
+[@bs.send]
+external trackSchemaFromEvent: (t, string, Js.Json.t) => Js.Promise.t(unit) =
+  "trackSchemaFromEvent";

package/.claude/worktrees/release-1.1.1/src/AvoDeduplicator.ts

@@ -0,0 +1,146 @@
+import { deepEquals } from "./utils";
+
+export class AvoDeduplicator {
+  avoFunctionsEvents: { [time: number]: string } = {};
+  manualEvents: { [time: number]: string } = {};
+  private msToConsiderOld = 500;
+
+  avoFunctionsEventsParams: {
+    [eventName: string]: { [propName: string]: any };
+  } = {};
+  manualEventsParams: { [eventName: string]: { [propName: string]: any } } = {};
+
+  shouldRegisterEvent(
+    eventName: string,
+    params: { [propName: string]: any },
+    fromAvoFunction: boolean
+  ): boolean {
+    this.clearOldEvents();
+
+    if (fromAvoFunction) {
+      this.avoFunctionsEvents[Date.now()] = eventName;
+      this.avoFunctionsEventsParams[eventName] = params;
+    } else {
+      this.manualEvents[Date.now()] = eventName;
+      this.manualEventsParams[eventName] = params;
+    }
+
+    let checkInAvoFunctions = !fromAvoFunction;
+
+    return !this.hasSameEventAs(eventName, params, checkInAvoFunctions);
+  }
+
+  private hasSameEventAs(
+    eventName: string,
+    params: { [propName: string]: any },
+    checkInAvoFunctions: boolean
+  ): boolean {
+    let result = false;
+
+    if (checkInAvoFunctions) {
+      if (
+        this.lookForEventIn(eventName, params, this.avoFunctionsEventsParams)
+      ) {
+        result = true;
+      }
+    } else {
+      if (this.lookForEventIn(eventName, params, this.manualEventsParams)) {
+        result = true;
+      }
+    }
+
+    if (result) {
+      delete this.avoFunctionsEventsParams[eventName];
+      delete this.manualEventsParams[eventName];
+    }
+
+    return result;
+  }
+
+  private lookForEventIn(
+    eventName: string,
+    params: { [propName: string]: any },
+    eventsStorage: { [eventName: string]: { [propName: string]: any } }
+  ): boolean {
+    for (const otherEventName in eventsStorage) {
+      if (eventsStorage.hasOwnProperty(otherEventName)) {
+        if (otherEventName === eventName) {
+          const otherParams = eventsStorage[eventName];
+          if (otherParams && deepEquals(params, otherParams)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  hasSeenEventParams(
+    params: { [propName: string]: any },
+    checkInAvoFunctions: boolean
+  ) {
+    let result = false;
+
+    if (checkInAvoFunctions) {
+      if (this.lookForEventParamsIn(params, this.avoFunctionsEventsParams)) {
+        result = true;
+      }
+    } else {
+      if (this.lookForEventParamsIn(params, this.manualEventsParams)) {
+        result = true;
+      }
+    }
+
+    return result;
+  }
+
+  private lookForEventParamsIn(
+    params: { [propName: string]: any },
+    eventsStorage: { [eventName: string]: { [propName: string]: any } }
+  ): boolean {
+    for (const otherEventName in eventsStorage) {
+      if (eventsStorage.hasOwnProperty(otherEventName)) {
+        const otherParams = eventsStorage[otherEventName];
+        if (otherParams && deepEquals(params, otherParams)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private clearOldEvents() {
+    const now = Date.now();
+
+    for (const time in this.avoFunctionsEvents) {
+      if (this.avoFunctionsEvents.hasOwnProperty(time)) {
+        const timestamp = Number(time) || 0;
+        if (now - timestamp > this.msToConsiderOld) {
+          const eventName = this.avoFunctionsEvents[time];
+          delete this.avoFunctionsEvents[time];
+          delete this.avoFunctionsEventsParams[eventName];
+        }
+      }
+    }
+
+    for (const time in this.manualEvents) {
+      if (this.manualEvents.hasOwnProperty(time)) {
+        const timestamp = Number(time) || 0;
+        if (now - timestamp > this.msToConsiderOld) {
+          const eventName = this.manualEvents[time];
+          delete this.manualEvents[time];
+          delete this.manualEventsParams[eventName];
+        }
+      }
+    }
+  }
+
+  // used in tests
+  private _clearEvents() {
+    this.avoFunctionsEvents = {};
+    this.manualEvents = {};
+
+    this.avoFunctionsEventsParams = {};
+    this.manualEventsParams = {};
+  }
+}

package/.claude/worktrees/release-1.1.1/src/AvoEncryption.ts

@@ -0,0 +1,90 @@
+import * as crypto from "crypto";
+
+export class AvoEncryption {
+  /**
+   * Determines whether encryption should be applied.
+   *
+   * Truth table:
+   *   dev + key    => true
+   *   staging + key => true
+   *   prod + key   => false
+   *   dev + null   => false
+   *   dev + ""     => false
+   */
+  static shouldEncrypt(
+    env: string,
+    publicEncryptionKey: string | undefined | null
+  ): boolean {
+    if (!publicEncryptionKey || publicEncryptionKey.length === 0) {
+      return false;
+    }
+    if (env === "prod") {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Returns true if the propertyType represents a list type (e.g. "list(string)").
+   */
+  static isListType(propertyType: string): boolean {
+    return propertyType.startsWith("list(");
+  }
+
+  /**
+   * Encrypts a string value using ECIES with prime256v1.
+   *
+   * Wire format: [0x00][65-byte ephemeral pubkey][16-byte IV][16-byte auth tag][ciphertext]
+   * Output is base64-encoded.
+   *
+   * Returns null on failure, logging a warning.
+   */
+  static encryptValue(
+    value: string,
+    recipientPubKeyHex: string
+  ): string | null {
+    try {
+      const recipientPubKey = Buffer.from(recipientPubKeyHex, "hex");
+
+      // Generate ephemeral key pair
+      const ecdh = crypto.createECDH("prime256v1");
+      ecdh.generateKeys();
+      const ephemeralPubKey = ecdh.getPublicKey(); // 65 bytes, uncompressed
+
+      // Compute shared secret (raw 32-byte X-coordinate)
+      const sharedSecret = ecdh.computeSecret(recipientPubKey);
+
+      // Derive AES key via SHA-256
+      const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
+
+      // Generate random 16-byte IV
+      const iv = crypto.randomBytes(16);
+
+      // Encrypt with AES-256-GCM
+      const cipher = crypto.createCipheriv("aes-256-gcm", aesKey, iv, {
+        authTagLength: 16,
+      });
+      const encrypted = Buffer.concat([
+        cipher.update(value, "utf8"),
+        cipher.final(),
+      ]);
+      const authTag = cipher.getAuthTag(); // 16 bytes
+
+      // Assemble wire format: [version][ephemeralPubKey][IV][authTag][ciphertext]
+      const wire = Buffer.concat([
+        Buffer.from([0x00]), // version byte
+        ephemeralPubKey, // 65 bytes
+        iv, // 16 bytes
+        authTag, // 16 bytes
+        encrypted, // variable length
+      ]);
+
+      return wire.toString("base64");
+    } catch (e) {
+      console.warn(
+        `[Avo Inspector] Warning: encryption failed for value, omitting property. ${e}`
+      );
+      return null;
+    }
+  }
+}

package/.claude/worktrees/release-1.1.1/src/AvoGuid.ts

@@ -0,0 +1,9 @@
+export class AvoGuid {
+  static newGuid(): string {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      var r = (Math.random() * 16) | 0,
+        v = c == "x" ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+}