luchy 0.2.0 → 1.1.0

package/dist/server.js

@@ -1,40 +1,128 @@
-import { createLuchyClient } from "./api/index.js";
-const DEFAULT_ENDPOINT = "https://api.luchy.app/ingest";
+import { createLuchyClient, LuchyApiError } from "./api/index.js";
+const encoder = new TextEncoder();
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function signIdentity(identity, secret) {
+  const claims = { u: identity.user, a: identity.actor, t: identity.tenant };
+  const body = base64url(encoder.encode(JSON.stringify(claims)));
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+  return `${body}.${base64url(new Uint8Array(signature))}`;
+}
+const DEFAULT_ENDPOINT = "https://dash.luchy.app/api/ingest";
 function apiBaseFrom(endpoint) {
-  const withoutSlash = endpoint.replace(/\/+$/, "");
-  return withoutSlash.replace(/\/ingest$/, "");
+  return endpoint.replace(/\/+$/, "").replace(/\/ingest$/, "");
 }
-function createServerTracker(options) {
+function createLuchy(options) {
+  const enabled = options.enabled ?? true;
   const client = createLuchyClient({
     apiKey: options.apiKey,
     endpoint: apiBaseFrom(options.endpoint || DEFAULT_ENDPOINT),
+    fetch: options.fetch,
     onError: options.onError
   });
+  const secretApi = options.secret ? createLuchyClient({
+    apiKey: options.secret,
+    endpoint: apiBaseFrom(options.endpoint || DEFAULT_ENDPOINT),
+    fetch: options.fetch
+  }).api : void 0;
+  let reportedMissingSecret = false;
+  async function tokenFor(identity) {
+    if (!identity) {
+      return void 0;
+    }
+    if (typeof identity === "string") {
+      return identity;
+    }
+    if (!options.secret) {
+      return void 0;
+    }
+    return signIdentity(identity, options.secret);
+  }
   return {
-    async trackEvent(event) {
-      const body = {
-        name: event.name,
-        type: event.type,
-        pathname: event.pathname,
-        payload: event.payload,
-        userAgent: event.userAgent,
-        language: event.language,
-        country: event.country
-      };
-      await client.trackEvent(body);
+    async track(event, identity) {
+      if (!enabled) {
+        return;
+      }
+      try {
+        await client.trackEvent({
+          name: event.name,
+          type: event.type,
+          pathname: event.pathname,
+          payload: event.payload,
+          identity: await tokenFor(identity),
+          userAgent: event.userAgent,
+          ip: event.ip,
+          country: event.country,
+          language: event.language
+        });
+      } catch (error) {
+        options.onError?.(error);
+      }
+    },
+    async pageview(pageview, identity) {
+      if (!enabled) {
+        return;
+      }
+      try {
+        await client.trackPageview({
+          pathname: pageview.pathname,
+          referrer: pageview.referrer,
+          payload: pageview.payload,
+          identity: await tokenFor(identity),
+          userAgent: pageview.userAgent,
+          ip: pageview.ip,
+          country: pageview.country,
+          language: pageview.language
+        });
+      } catch (error) {
+        options.onError?.(error);
+      }
     },
-    async trackPageview(pageview) {
-      const body = {
-        pathname: pageview.pathname,
-        referrer: pageview.referrer,
-        userAgent: pageview.userAgent,
-        language: pageview.language,
-        country: pageview.country
-      };
-      await client.trackPageview(body);
+    async identify(user, traits) {
+      if (!enabled) {
+        return;
+      }
+      if (!secretApi) {
+        if (!reportedMissingSecret) {
+          reportedMissingSecret = true;
+          options.onError?.(
+            new Error("luchy: identify needs the `secret` option; skipped")
+          );
+        }
+        return;
+      }
+      try {
+        const { error, response } = await secretApi.POST("/ingest/identify", {
+          body: { user, traits }
+        });
+        if (error || !response.ok) {
+          options.onError?.(
+            new LuchyApiError(
+              `Luchy identify failed with ${response.status}`,
+              response.status
+            )
+          );
+        }
+      } catch (error) {
+        options.onError?.(error);
+      }
     }
   };
 }
 export {
-  createServerTracker
+  DEFAULT_ENDPOINT,
+  createLuchy,
+  signIdentity
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "luchy",
-  "version": "0.2.0",
-  "description": "Luchy tracking - browser script + server-side tracker",
+  "version": "1.1.0",
+  "description": "Luchy tracking - browser script, server tracker and React Router middleware",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -55,8 +55,11 @@
   },
   "devDependencies": {
     "@types/node": "^24.7.0",
+    "@types/react": "^19.2.2",
     "jsdom": "^25.0.1",
     "openapi-typescript": "^7.13.0",
+    "react": "^19.2.0",
+    "react-router": "^7.14.0",
     "terser": "^5.37.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
@@ -68,5 +71,17 @@
   },
   "dependencies": {
     "openapi-fetch": "^0.17.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-router": ">=7.9.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-router": {
+      "optional": true
+    }
   }
 }