@nextlytics/core 0.1.0-canary-1

package/dist/backends/logging.d.mts

@@ -0,0 +1,7 @@
+import { NextlyticsBackend } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+declare function loggingBackend(): NextlyticsBackend;
+
+export { loggingBackend };

package/dist/backends/logging.d.ts

@@ -0,0 +1,7 @@
+import { NextlyticsBackend } from '../types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+declare function loggingBackend(): NextlyticsBackend;
+
+export { loggingBackend };

package/dist/backends/logging.js

@@ -0,0 +1,21 @@
+function loggingBackend() {
+  return {
+    name: "logging",
+    supportsUpdates: true,
+    async onEvent(event) {
+      const { type, eventId, serverContext, ...rest } = event;
+      const method = serverContext?.method || "";
+      const path = serverContext?.path || "";
+      const route = method && path ? `${method} ${path}` : "";
+      console.log(`[Nextlytics Log] ${type}${route ? ` ${route}` : ""} (${eventId})`);
+      console.log(JSON.stringify({ serverContext, ...rest }, null, 2));
+    },
+    updateEvent(eventId, patch) {
+      console.log(`[Nextlytics Log] Update ${eventId}`);
+      console.log(JSON.stringify(patch, null, 2));
+    }
+  };
+}
+export {
+  loggingBackend
+};

package/dist/backends/neon.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var neon_exports = {};
+__export(neon_exports, {
+  neonBackend: () => neonBackend
+});
+module.exports = __toCommonJS(neon_exports);
+var import_serverless = require("@neondatabase/serverless");
+var import_db = require("./lib/db");
+function neonBackend(config) {
+  const sql = (0, import_serverless.neon)(config.databaseUrl);
+  const table = config.tableName ?? "analytics";
+  function printCreateTableStatement() {
+    console.error(`[Nextlytics Neon] Table "${table}" does not exist. Run this SQL:
+`);
+    console.error((0, import_db.generatePgCreateTableSQL)(table));
+  }
+  return {
+    name: "neon",
+    supportsUpdates: true,
+    async onEvent(event) {
+      const values = (0, import_db.eventToRow)(event);
+      const cols = import_db.tableColumns.map((c) => c.name).join(", ");
+      const placeholders = import_db.tableColumns.map((_, i) => `$${i + 1}`).join(", ");
+      try {
+        await sql(`INSERT INTO ${table} (${cols}) VALUES (${placeholders})`, [
+          ...import_db.tableColumns.map((c) => values[c.name])
+        ]);
+      } catch (err) {
+        if ((0, import_db.isPgTableNotFoundError)(err)) {
+          printCreateTableStatement();
+        }
+        throw err;
+      }
+    },
+    async updateEvent(eventId, patch) {
+      const sets = [];
+      const params = [];
+      let paramIndex = 1;
+      if (patch.clientContext) {
+        const clientCtx = (0, import_db.extractClientContext)(patch.clientContext);
+        const columns = {
+          referer: clientCtx.referer,
+          user_agent: clientCtx.user_agent,
+          locale: clientCtx.locale
+        };
+        for (const [col, val] of Object.entries(columns)) {
+          if (val !== void 0) {
+            sets.push(`${col} = $${paramIndex++}`);
+            params.push(val);
+          }
+        }
+        if (clientCtx.rest) {
+          sets.push(`client_context = $${paramIndex++}::jsonb`);
+          params.push(JSON.stringify(clientCtx.rest));
+        }
+      }
+      if (sets.length > 0) {
+        params.push(eventId);
+        await sql(`UPDATE ${table} SET ${sets.join(", ")} WHERE event_id = $${paramIndex}`, params);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  neonBackend
+});

package/dist/backends/neon.d.mts

@@ -0,0 +1,11 @@
+import { NextlyticsBackend } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type NeonBackendConfig = {
+    databaseUrl: string;
+    tableName?: string;
+};
+declare function neonBackend(config: NeonBackendConfig): NextlyticsBackend;
+
+export { type NeonBackendConfig, neonBackend };

package/dist/backends/neon.d.ts

@@ -0,0 +1,11 @@
+import { NextlyticsBackend } from '../types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type NeonBackendConfig = {
+    databaseUrl: string;
+    tableName?: string;
+};
+declare function neonBackend(config: NeonBackendConfig): NextlyticsBackend;
+
+export { type NeonBackendConfig, neonBackend };

package/dist/backends/neon.js

@@ -0,0 +1,66 @@
+import { neon } from "@neondatabase/serverless";
+import {
+  tableColumns,
+  eventToRow,
+  extractClientContext,
+  generatePgCreateTableSQL,
+  isPgTableNotFoundError
+} from "./lib/db";
+function neonBackend(config) {
+  const sql = neon(config.databaseUrl);
+  const table = config.tableName ?? "analytics";
+  function printCreateTableStatement() {
+    console.error(`[Nextlytics Neon] Table "${table}" does not exist. Run this SQL:
+`);
+    console.error(generatePgCreateTableSQL(table));
+  }
+  return {
+    name: "neon",
+    supportsUpdates: true,
+    async onEvent(event) {
+      const values = eventToRow(event);
+      const cols = tableColumns.map((c) => c.name).join(", ");
+      const placeholders = tableColumns.map((_, i) => `$${i + 1}`).join(", ");
+      try {
+        await sql(`INSERT INTO ${table} (${cols}) VALUES (${placeholders})`, [
+          ...tableColumns.map((c) => values[c.name])
+        ]);
+      } catch (err) {
+        if (isPgTableNotFoundError(err)) {
+          printCreateTableStatement();
+        }
+        throw err;
+      }
+    },
+    async updateEvent(eventId, patch) {
+      const sets = [];
+      const params = [];
+      let paramIndex = 1;
+      if (patch.clientContext) {
+        const clientCtx = extractClientContext(patch.clientContext);
+        const columns = {
+          referer: clientCtx.referer,
+          user_agent: clientCtx.user_agent,
+          locale: clientCtx.locale
+        };
+        for (const [col, val] of Object.entries(columns)) {
+          if (val !== void 0) {
+            sets.push(`${col} = $${paramIndex++}`);
+            params.push(val);
+          }
+        }
+        if (clientCtx.rest) {
+          sets.push(`client_context = $${paramIndex++}::jsonb`);
+          params.push(JSON.stringify(clientCtx.rest));
+        }
+      }
+      if (sets.length > 0) {
+        params.push(eventId);
+        await sql(`UPDATE ${table} SET ${sets.join(", ")} WHERE event_id = $${paramIndex}`, params);
+      }
+    }
+  };
+}
+export {
+  neonBackend
+};

package/dist/backends/postgrest.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postgrest_exports = {};
+__export(postgrest_exports, {
+  generatePgCreateTableSQL: () => import_db2.generatePgCreateTableSQL,
+  postgrestBackend: () => postgrestBackend
+});
+module.exports = __toCommonJS(postgrest_exports);
+var import_db = require("./lib/db");
+var import_db2 = require("./lib/db");
+function postgrestBackend(config) {
+  const table = config.tableName ?? "analytics";
+  const baseUrl = config.url.replace(/\/$/, "");
+  function headers() {
+    const h = {
+      "Content-Type": "application/json",
+      Prefer: "return=minimal"
+    };
+    if (config.apiKey) {
+      h["apikey"] = config.apiKey;
+      h["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+    return h;
+  }
+  function printCreateTableStatement() {
+    console.error(`[Nextlytics PostgREST] Table "${table}" does not exist. Run this SQL:
+`);
+    console.error((0, import_db.generatePgCreateTableSQL)(table));
+  }
+  async function handleResponse(res) {
+    if (!res.ok) {
+      const text = await res.text();
+      if (text.includes("does not exist") || res.status === 404) {
+        printCreateTableStatement();
+      }
+      throw new Error(`PostgREST error ${res.status}: ${text}`);
+    }
+  }
+  return {
+    name: "postgrest",
+    supportsUpdates: true,
+    async onEvent(event) {
+      const row = (0, import_db.eventToJsonRow)(event);
+      const res = await fetch(`${baseUrl}/${table}`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(row)
+      });
+      await handleResponse(res);
+    },
+    async updateEvent(eventId, patch) {
+      const updates = {};
+      if (patch.clientContext) {
+        const clientCtx = (0, import_db.extractClientContext)(patch.clientContext);
+        if (clientCtx.referer !== void 0) updates.referer = clientCtx.referer;
+        if (clientCtx.user_agent !== void 0) updates.user_agent = clientCtx.user_agent;
+        if (clientCtx.locale !== void 0) updates.locale = clientCtx.locale;
+        if (clientCtx.rest) updates.client_context = clientCtx.rest;
+      }
+      if (patch.userContext) {
+        updates.user_id = patch.userContext.userId;
+        if (patch.userContext.traits?.email) updates.user_email = patch.userContext.traits.email;
+        if (patch.userContext.traits?.name) updates.user_name = patch.userContext.traits.name;
+      }
+      if (patch.anonymousUserId) {
+        updates.anonymous_user_id = patch.anonymousUserId;
+      }
+      if (Object.keys(updates).length === 0) return;
+      const res = await fetch(`${baseUrl}/${table}?event_id=eq.${encodeURIComponent(eventId)}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(updates)
+      });
+      await handleResponse(res);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generatePgCreateTableSQL,
+  postgrestBackend
+});

package/dist/backends/postgrest.d.mts

@@ -0,0 +1,46 @@
+import { NextlyticsBackend } from '../types.mjs';
+export { AnalyticsEventRow, generatePgCreateTableSQL } from './lib/db.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/**
+ * PostgREST backend for Nextlytics
+ *
+ * Works with any PostgREST-compatible API including Supabase.
+ *
+ * ## Supabase Usage
+ *
+ * ```typescript
+ * import { postgrestBackend } from "@nextlytics/core/backends/postgrest"
+ *
+ * const analytics = Nextlytics({
+ *   backends: [
+ *     postgrestBackend({
+ *       url: process.env.SUPABASE_URL! + "/rest/v1",
+ *       apiKey: process.env.SUPABASE_SERVICE_ROLE_KEY!,
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * ## Generic PostgREST Usage
+ *
+ * ```typescript
+ * postgrestBackend({
+ *   url: "https://your-postgrest-server.com",
+ *   // apiKey is optional for non-Supabase PostgREST
+ * })
+ * ```
+ */
+
+type PostgrestBackendConfig = {
+    /** PostgREST API URL (e.g., "https://xxx.supabase.co/rest/v1") */
+    url: string;
+    /** API key for authentication (required for Supabase) */
+    apiKey?: string;
+    /** Table name (default: "analytics") */
+    tableName?: string;
+};
+declare function postgrestBackend(config: PostgrestBackendConfig): NextlyticsBackend;
+
+export { type PostgrestBackendConfig, postgrestBackend };

package/dist/backends/postgrest.d.ts

@@ -0,0 +1,46 @@
+import { NextlyticsBackend } from '../types.js';
+export { AnalyticsEventRow, generatePgCreateTableSQL } from './lib/db.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/**
+ * PostgREST backend for Nextlytics
+ *
+ * Works with any PostgREST-compatible API including Supabase.
+ *
+ * ## Supabase Usage
+ *
+ * ```typescript
+ * import { postgrestBackend } from "@nextlytics/core/backends/postgrest"
+ *
+ * const analytics = Nextlytics({
+ *   backends: [
+ *     postgrestBackend({
+ *       url: process.env.SUPABASE_URL! + "/rest/v1",
+ *       apiKey: process.env.SUPABASE_SERVICE_ROLE_KEY!,
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * ## Generic PostgREST Usage
+ *
+ * ```typescript
+ * postgrestBackend({
+ *   url: "https://your-postgrest-server.com",
+ *   // apiKey is optional for non-Supabase PostgREST
+ * })
+ * ```
+ */
+
+type PostgrestBackendConfig = {
+    /** PostgREST API URL (e.g., "https://xxx.supabase.co/rest/v1") */
+    url: string;
+    /** API key for authentication (required for Supabase) */
+    apiKey?: string;
+    /** Table name (default: "analytics") */
+    tableName?: string;
+};
+declare function postgrestBackend(config: PostgrestBackendConfig): NextlyticsBackend;
+
+export { type PostgrestBackendConfig, postgrestBackend };

package/dist/backends/postgrest.js

@@ -0,0 +1,73 @@
+import { eventToJsonRow, extractClientContext, generatePgCreateTableSQL } from "./lib/db";
+import { generatePgCreateTableSQL as generatePgCreateTableSQL2 } from "./lib/db";
+function postgrestBackend(config) {
+  const table = config.tableName ?? "analytics";
+  const baseUrl = config.url.replace(/\/$/, "");
+  function headers() {
+    const h = {
+      "Content-Type": "application/json",
+      Prefer: "return=minimal"
+    };
+    if (config.apiKey) {
+      h["apikey"] = config.apiKey;
+      h["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+    return h;
+  }
+  function printCreateTableStatement() {
+    console.error(`[Nextlytics PostgREST] Table "${table}" does not exist. Run this SQL:
+`);
+    console.error(generatePgCreateTableSQL(table));
+  }
+  async function handleResponse(res) {
+    if (!res.ok) {
+      const text = await res.text();
+      if (text.includes("does not exist") || res.status === 404) {
+        printCreateTableStatement();
+      }
+      throw new Error(`PostgREST error ${res.status}: ${text}`);
+    }
+  }
+  return {
+    name: "postgrest",
+    supportsUpdates: true,
+    async onEvent(event) {
+      const row = eventToJsonRow(event);
+      const res = await fetch(`${baseUrl}/${table}`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(row)
+      });
+      await handleResponse(res);
+    },
+    async updateEvent(eventId, patch) {
+      const updates = {};
+      if (patch.clientContext) {
+        const clientCtx = extractClientContext(patch.clientContext);
+        if (clientCtx.referer !== void 0) updates.referer = clientCtx.referer;
+        if (clientCtx.user_agent !== void 0) updates.user_agent = clientCtx.user_agent;
+        if (clientCtx.locale !== void 0) updates.locale = clientCtx.locale;
+        if (clientCtx.rest) updates.client_context = clientCtx.rest;
+      }
+      if (patch.userContext) {
+        updates.user_id = patch.userContext.userId;
+        if (patch.userContext.traits?.email) updates.user_email = patch.userContext.traits.email;
+        if (patch.userContext.traits?.name) updates.user_name = patch.userContext.traits.name;
+      }
+      if (patch.anonymousUserId) {
+        updates.anonymous_user_id = patch.anonymousUserId;
+      }
+      if (Object.keys(updates).length === 0) return;
+      const res = await fetch(`${baseUrl}/${table}?event_id=eq.${encodeURIComponent(eventId)}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(updates)
+      });
+      await handleResponse(res);
+    }
+  };
+}
+export {
+  generatePgCreateTableSQL2 as generatePgCreateTableSQL,
+  postgrestBackend
+};

package/dist/backends/posthog.cjs

@@ -0,0 +1,120 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var posthog_exports = {};
+__export(posthog_exports, {
+  posthogBackend: () => posthogBackend
+});
+module.exports = __toCommonJS(posthog_exports);
+function posthogBackend(opts) {
+  const host = (opts.host ?? "https://app.posthog.com").replace(/\/$/, "");
+  const apiKey = opts.apiKey;
+  return {
+    name: "posthog",
+    supportsUpdates: false,
+    async onEvent(event) {
+      const {
+        type,
+        eventId,
+        parentEventId,
+        collectedAt,
+        userContext,
+        clientContext,
+        serverContext,
+        properties,
+        anonymousUserId
+      } = event;
+      const posthogProps = {
+        ...properties,
+        nextlytics_event_id: eventId
+      };
+      if (parentEventId) {
+        posthogProps.nextlytics_parent_event_id = parentEventId;
+      }
+      posthogProps.nextlytics_collected_at = collectedAt;
+      posthogProps.$current_url = `${serverContext.host}${serverContext.path}`;
+      posthogProps.$pathname = serverContext.path;
+      posthogProps.$host = serverContext.host;
+      posthogProps.$ip = serverContext.ip;
+      posthogProps.http_method = serverContext.method;
+      posthogProps.server_collected_at = serverContext.collectedAt;
+      if (serverContext.search && Object.keys(serverContext.search).length > 0) {
+        posthogProps.query_params = serverContext.search;
+      }
+      if (serverContext.requestHeaders && Object.keys(serverContext.requestHeaders).length > 0) {
+        posthogProps.request_headers = serverContext.requestHeaders;
+      }
+      if (serverContext.responseHeaders && Object.keys(serverContext.responseHeaders).length > 0) {
+        posthogProps.response_headers = serverContext.responseHeaders;
+      }
+      const referer = clientContext?.referer ?? serverContext.requestHeaders?.["referer"];
+      if (referer) {
+        posthogProps.$referrer = referer;
+      }
+      const userAgent = clientContext?.userAgent ?? serverContext.requestHeaders?.["user-agent"];
+      if (userAgent) {
+        posthogProps.$user_agent = userAgent;
+      }
+      if (clientContext) {
+        posthogProps.client_collected_at = clientContext.collectedAt;
+        if (clientContext.path) {
+          posthogProps.client_path = clientContext.path;
+        }
+        if (clientContext.locale) {
+          posthogProps.$locale = clientContext.locale;
+        }
+        if (clientContext.screen) {
+          const { screen } = clientContext;
+          if (screen.width) posthogProps.$screen_width = screen.width;
+          if (screen.height) posthogProps.$screen_height = screen.height;
+          if (screen.innerWidth) posthogProps.$viewport_width = screen.innerWidth;
+          if (screen.innerHeight) posthogProps.$viewport_height = screen.innerHeight;
+          if (screen.density) posthogProps.$device_pixel_ratio = screen.density;
+        }
+      }
+      const distinctId = userContext?.userId ?? anonymousUserId ?? "anonymous";
+      const payload = {
+        api_key: apiKey,
+        event: type,
+        distinct_id: distinctId,
+        properties: posthogProps,
+        timestamp: collectedAt
+      };
+      if (userContext?.userId && userContext.traits) {
+        payload.$set = userContext.traits;
+      }
+      const res = await fetch(`${host}/capture/`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`PostHog error ${res.status}: ${text}`);
+      }
+    },
+    updateEvent() {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  posthogBackend
+});

package/dist/backends/posthog.d.mts

@@ -0,0 +1,13 @@
+import { NextlyticsBackend } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type PosthogBackendOptions = {
+    /** PostHog project API key */
+    apiKey: string;
+    /** PostHog host (default: "https://app.posthog.com") */
+    host?: string;
+};
+declare function posthogBackend(opts: PosthogBackendOptions): NextlyticsBackend;
+
+export { type PosthogBackendOptions, posthogBackend };

package/dist/backends/posthog.d.ts

@@ -0,0 +1,13 @@
+import { NextlyticsBackend } from '../types.js';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type PosthogBackendOptions = {
+    /** PostHog project API key */
+    apiKey: string;
+    /** PostHog host (default: "https://app.posthog.com") */
+    host?: string;
+};
+declare function posthogBackend(opts: PosthogBackendOptions): NextlyticsBackend;
+
+export { type PosthogBackendOptions, posthogBackend };