@pulsekit/core 0.0.1

package/dist/cli.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_postgres = __toESM(require("postgres"));
+async function main() {
+  const url = process.env.DATABASE_URL;
+  if (!url) throw new Error("DATABASE_URL is required");
+  const sql = (0, import_postgres.default)(url, { max: 1 });
+  const sqlDir = import_node_path.default.join(__dirname, "../sql");
+  const files = import_node_fs.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  for (const file of files) {
+    const text = import_node_fs.default.readFileSync(import_node_path.default.join(sqlDir, file), "utf8");
+    await sql.unsafe(text);
+    console.log(`Applied: ${file}`);
+  }
+  await sql.end();
+  console.log("Pulse migration complete.");
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+type Timeframe = "7d" | "30d";
+type WebVitalRating = "good" | "needs-improvement" | "poor";
+interface WebVitalStat {
+    metric: string;
+    p75: number;
+    sampleCount: number;
+    rating: WebVitalRating;
+}
+interface PageVitalsStat {
+    path: string;
+    vitals: Record<string, WebVitalStat>;
+}
+interface VitalsOverview {
+    overall: WebVitalStat[];
+    byPage: PageVitalsStat[];
+}
+interface DailyStat {
+    date: string;
+    totalViews: number;
+    uniqueVisitors: number;
+}
+interface TopPageStat {
+    path: string;
+    totalViews: number;
+    uniqueVisitors: number;
+}
+interface LocationStat {
+    country: string;
+    city: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    totalViews: number;
+    uniqueVisitors: number;
+}
+interface PulseStats {
+    daily: DailyStat[];
+    topPages: TopPageStat[];
+    locations: LocationStat[];
+}
+declare function getPulseStats(opts: {
+    supabase: SupabaseClient;
+    siteId: string;
+    timeframe: Timeframe;
+    timezone?: string;
+}): Promise<PulseStats>;
+declare function getPulseVitals(opts: {
+    supabase: SupabaseClient;
+    siteId: string;
+    timeframe: Timeframe;
+}): Promise<VitalsOverview>;
+
+type PulseEventType = "pageview" | "custom" | "vitals";
+interface PulseEventPayload {
+    type: PulseEventType;
+    path: string;
+    sessionId?: string;
+    meta?: Record<string, unknown>;
+    createdAt?: string;
+}
+
+export { type DailyStat, type LocationStat, type PageVitalsStat, type PulseEventPayload, type PulseEventType, type PulseStats, type Timeframe, type TopPageStat, type VitalsOverview, type WebVitalRating, type WebVitalStat, getPulseStats, getPulseVitals };

package/dist/index.mjs

@@ -0,0 +1,139 @@
+// src/queries.ts
+var VITAL_THRESHOLDS = {
+  lcp: [2500, 4e3],
+  inp: [200, 500],
+  cls: [0.1, 0.25],
+  fcp: [1800, 3e3],
+  ttfb: [800, 1800]
+};
+function rateVital(metric, p75) {
+  const thresholds = VITAL_THRESHOLDS[metric];
+  if (!thresholds) return "good";
+  if (p75 <= thresholds[0]) return "good";
+  if (p75 <= thresholds[1]) return "needs-improvement";
+  return "poor";
+}
+function daysFromTimeframe(timeframe) {
+  return timeframe === "7d" ? 7 : 30;
+}
+function cutoffDate(timeframe, timezone) {
+  const days = daysFromTimeframe(timeframe);
+  const now = /* @__PURE__ */ new Date();
+  const localNow = new Date(
+    now.toLocaleString("en-US", { timeZone: timezone })
+  );
+  localNow.setDate(localNow.getDate() - (days - 1));
+  return localNow.toISOString().slice(0, 10);
+}
+async function getPulseStats(opts) {
+  const { supabase, siteId, timeframe, timezone = "UTC" } = opts;
+  const days = daysFromTimeframe(timeframe);
+  const since = cutoffDate(timeframe, timezone);
+  const { data: rows, error } = await supabase.schema("analytics").rpc("pulse_stats_by_timezone", {
+    p_site_id: siteId,
+    p_timezone: timezone,
+    p_days_back: days
+  });
+  const { data: locationRows, error: locationError } = await supabase.schema("analytics").rpc("pulse_location_stats", {
+    p_site_id: siteId,
+    p_days_back: days
+  });
+  if (error) throw error;
+  if (locationError) throw locationError;
+  const locations = (locationRows ?? []).map(
+    (row) => ({
+      country: row.country,
+      city: row.city ?? null,
+      latitude: row.latitude ?? null,
+      longitude: row.longitude ?? null,
+      totalViews: Number(row.total_views),
+      uniqueVisitors: Number(row.unique_visitors)
+    })
+  );
+  if (!rows || rows.length === 0) {
+    return { daily: [], topPages: [], locations };
+  }
+  const byDate = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const d = String(row.date);
+    if (d < since) continue;
+    const existing = byDate.get(d);
+    if (existing) {
+      existing.views += Number(row.total_views);
+      existing.unique += Number(row.unique_visitors);
+    } else {
+      byDate.set(d, {
+        views: Number(row.total_views),
+        unique: Number(row.unique_visitors)
+      });
+    }
+  }
+  const daily = Array.from(byDate.entries()).map(
+    ([date, { views, unique }]) => ({
+      date,
+      totalViews: views,
+      uniqueVisitors: unique
+    })
+  );
+  const byPath = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const d = String(row.date);
+    if (d < since) continue;
+    const p = row.path;
+    const existing = byPath.get(p);
+    if (existing) {
+      existing.views += Number(row.total_views);
+      existing.unique += Number(row.unique_visitors);
+    } else {
+      byPath.set(p, {
+        views: Number(row.total_views),
+        unique: Number(row.unique_visitors)
+      });
+    }
+  }
+  const topPages = Array.from(byPath.entries()).map(([path, { views, unique }]) => ({
+    path,
+    totalViews: views,
+    uniqueVisitors: unique
+  })).sort((a, b) => b.totalViews - a.totalViews).slice(0, 10);
+  return { daily, topPages, locations };
+}
+async function getPulseVitals(opts) {
+  const { supabase, siteId, timeframe } = opts;
+  const days = daysFromTimeframe(timeframe);
+  const { data: rows, error } = await supabase.schema("analytics").rpc("pulse_vitals_stats", {
+    p_site_id: siteId,
+    p_days_back: days
+  });
+  if (error) throw error;
+  const overall = [];
+  const pageMap = /* @__PURE__ */ new Map();
+  for (const row of rows ?? []) {
+    const stat = {
+      metric: row.metric,
+      p75: Number(row.p75),
+      sampleCount: Number(row.sample_count),
+      rating: rateVital(row.metric, Number(row.p75))
+    };
+    if (row.path === "__overall__") {
+      overall.push(stat);
+    } else {
+      let entry = pageMap.get(row.path);
+      if (!entry) {
+        entry = {};
+        pageMap.set(row.path, entry);
+      }
+      entry[row.metric] = stat;
+    }
+  }
+  const byPage = Array.from(pageMap.entries()).map(([path, vitals]) => ({ path, vitals })).sort((a, b) => {
+    const aLcp = a.vitals.lcp?.sampleCount ?? 0;
+    const bLcp = b.vitals.lcp?.sampleCount ?? 0;
+    return bLcp - aLcp;
+  }).slice(0, 10);
+  return { overall, byPage };
+}
+export {
+  getPulseStats,
+  getPulseVitals
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pulsekit/core",
+  "version": "0.0.1",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "bin": {
+    "pulse-init": "./dist/cli.js"
+  },
+  "dependencies": {
+    "postgres": "^3.4.0"
+  },
+  "devDependencies": {
+    "@supabase/supabase-js": "^2.49.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": ">=2.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  }
+}