mytart 0.1.0

package/dist/index.js

@@ -0,0 +1,771 @@
+"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 __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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmplitudeProvider: () => AmplitudeProvider,
+  BaseProvider: () => BaseProvider,
+  GoogleAnalyticsProvider: () => GoogleAnalyticsProvider,
+  MixpanelProvider: () => MixpanelProvider,
+  Mytart: () => Mytart,
+  PlausibleProvider: () => PlausibleProvider,
+  PostHogProvider: () => PostHogProvider,
+  SegmentProvider: () => SegmentProvider,
+  VercelAnalyticsProvider: () => VercelAnalyticsProvider
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/base.ts
+var BaseProvider = class {
+  buildError(message, code, originalError) {
+    return {
+      provider: this.name,
+      success: false,
+      error: {
+        message,
+        code,
+        provider: this.name,
+        originalError
+      }
+    };
+  }
+  buildSuccess(statusCode) {
+    return {
+      provider: this.name,
+      success: true,
+      statusCode
+    };
+  }
+};
+
+// src/utils/http.ts
+var import_axios = __toESM(require("axios"));
+function createHttpClient() {
+  const instance = import_axios.default.create({
+    timeout: 1e4,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  return instance;
+}
+function isAxiosError(error) {
+  return import_axios.default.isAxiosError(error);
+}
+
+// src/providers/google-analytics.ts
+var GA4_ENDPOINT = "https://www.google-analytics.com/mp/collect";
+var GA4_DEBUG_ENDPOINT = "https://www.google-analytics.com/debug/mp/collect";
+var GoogleAnalyticsProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "google-analytics";
+    this.config = config;
+    this.http = createHttpClient();
+    this.endpoint = config.debug ? GA4_DEBUG_ENDPOINT : GA4_ENDPOINT;
+  }
+  async track({ event, properties, userId, anonymousId, timestamp }) {
+    try {
+      const clientId = anonymousId ?? this.config.clientId ?? "anonymous";
+      const params = { ...properties };
+      if (timestamp) {
+        params["timestamp_micros"] = timestamp.getTime() * 1e3;
+      }
+      const body = {
+        client_id: clientId,
+        events: [{ name: event, params }]
+      };
+      if (userId) {
+        body["user_id"] = userId;
+      }
+      const response = await this.http.post(this.endpoint, body, {
+        params: {
+          measurement_id: this.config.measurementId,
+          api_secret: this.config.apiSecret
+        }
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `GA4_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "GA4_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify({ userId, traits }) {
+    try {
+      const body = {
+        client_id: userId,
+        user_id: userId,
+        user_properties: traits ? Object.fromEntries(
+          Object.entries(traits).map(([k, v]) => [k, { value: v }])
+        ) : void 0,
+        events: [{ name: "identify", params: {} }]
+      };
+      const response = await this.http.post(this.endpoint, body, {
+        params: {
+          measurement_id: this.config.measurementId,
+          api_secret: this.config.apiSecret
+        }
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `GA4_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "GA4_UNKNOWN_ERROR", error);
+    }
+  }
+  async page({ name, url, referrer, userId, anonymousId }) {
+    return this.track({
+      event: "page_view",
+      properties: {
+        page_title: name,
+        page_location: url,
+        page_referrer: referrer
+      },
+      userId,
+      anonymousId
+    });
+  }
+};
+
+// src/providers/mixpanel.ts
+var MIXPANEL_TRACK_ENDPOINT = "https://api.mixpanel.com/track";
+var MIXPANEL_ENGAGE_ENDPOINT = "https://api.mixpanel.com/engage";
+var MixpanelProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "mixpanel";
+    this.config = config;
+    this.http = createHttpClient();
+  }
+  encodeData(payload) {
+    const json = JSON.stringify(payload);
+    const base64 = Buffer.from(json).toString("base64");
+    return base64;
+  }
+  async track({ event, properties, userId, anonymousId, timestamp }) {
+    try {
+      const distinctId = userId ?? anonymousId ?? "anonymous";
+      const eventPayload = [
+        {
+          event,
+          properties: {
+            token: this.config.token,
+            distinct_id: distinctId,
+            time: timestamp ? Math.floor(timestamp.getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+            ...properties
+          }
+        }
+      ];
+      const endpoint = this.config.apiUrl ?? MIXPANEL_TRACK_ENDPOINT;
+      const response = await this.http.post(
+        endpoint,
+        `data=${this.encodeData(eventPayload)}`,
+        {
+          headers: { "Content-Type": "application/x-www-form-urlencoded" }
+        }
+      );
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `MIXPANEL_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "MIXPANEL_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify({ userId, traits }) {
+    try {
+      const engagePayload = [
+        {
+          $token: this.config.token,
+          $distinct_id: userId,
+          $set: traits ?? {}
+        }
+      ];
+      const endpoint = this.config.apiUrl ? this.config.apiUrl.replace("/track", "/engage") : MIXPANEL_ENGAGE_ENDPOINT;
+      const response = await this.http.post(
+        endpoint,
+        `data=${this.encodeData(engagePayload)}`,
+        {
+          headers: { "Content-Type": "application/x-www-form-urlencoded" }
+        }
+      );
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `MIXPANEL_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "MIXPANEL_UNKNOWN_ERROR", error);
+    }
+  }
+  async page({ name, url, userId, anonymousId, properties }) {
+    return this.track({
+      event: "Page View",
+      properties: {
+        page_name: name,
+        url,
+        ...properties
+      },
+      userId,
+      anonymousId
+    });
+  }
+};
+
+// src/providers/segment.ts
+var SEGMENT_BASE_URL = "https://api.segment.io/v1";
+var SegmentProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "segment";
+    this.config = config;
+    this.http = createHttpClient();
+    this.baseUrl = config.apiUrl ?? SEGMENT_BASE_URL;
+  }
+  getAuth() {
+    return { username: this.config.writeKey, password: "" };
+  }
+  async track({ event, properties, userId, anonymousId, timestamp, context }) {
+    try {
+      const body = {
+        event,
+        properties: properties ?? {},
+        context: context ?? {},
+        timestamp: (timestamp ?? /* @__PURE__ */ new Date()).toISOString()
+      };
+      if (userId) {
+        body["userId"] = userId;
+      } else {
+        body["anonymousId"] = anonymousId ?? "anonymous";
+      }
+      const response = await this.http.post(`${this.baseUrl}/track`, body, {
+        auth: this.getAuth()
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `SEGMENT_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "SEGMENT_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify({ userId, traits, anonymousId, timestamp }) {
+    try {
+      const body = {
+        userId,
+        traits: traits ?? {},
+        timestamp: (timestamp ?? /* @__PURE__ */ new Date()).toISOString()
+      };
+      if (anonymousId) {
+        body["anonymousId"] = anonymousId;
+      }
+      const response = await this.http.post(`${this.baseUrl}/identify`, body, {
+        auth: this.getAuth()
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `SEGMENT_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "SEGMENT_UNKNOWN_ERROR", error);
+    }
+  }
+  async page({ name, url, referrer, properties, userId, anonymousId, timestamp }) {
+    try {
+      const body = {
+        name,
+        properties: {
+          url,
+          referrer,
+          ...properties
+        },
+        timestamp: (timestamp ?? /* @__PURE__ */ new Date()).toISOString()
+      };
+      if (userId) {
+        body["userId"] = userId;
+      } else {
+        body["anonymousId"] = anonymousId ?? "anonymous";
+      }
+      const response = await this.http.post(`${this.baseUrl}/page`, body, {
+        auth: this.getAuth()
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `SEGMENT_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "SEGMENT_UNKNOWN_ERROR", error);
+    }
+  }
+};
+
+// src/providers/amplitude.ts
+var AMPLITUDE_ENDPOINT = "https://api2.amplitude.com/2/httpapi";
+var AmplitudeProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "amplitude";
+    this.config = config;
+    this.http = createHttpClient();
+    this.endpoint = config.apiUrl ?? AMPLITUDE_ENDPOINT;
+  }
+  async track({ event, properties, userId, anonymousId, timestamp }) {
+    try {
+      const amplitudeEvent = {
+        event_type: event,
+        event_properties: properties ?? {}
+      };
+      if (userId) {
+        amplitudeEvent["user_id"] = userId;
+      } else {
+        amplitudeEvent["device_id"] = anonymousId ?? "anonymous";
+      }
+      if (timestamp) {
+        amplitudeEvent["time"] = timestamp.getTime();
+      }
+      const body = {
+        api_key: this.config.apiKey,
+        events: [amplitudeEvent]
+      };
+      const response = await this.http.post(this.endpoint, body);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `AMPLITUDE_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "AMPLITUDE_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify({ userId, traits }) {
+    try {
+      const amplitudeEvent = {
+        event_type: "$identify",
+        user_id: userId,
+        user_properties: {
+          $set: traits ?? {}
+        }
+      };
+      const body = {
+        api_key: this.config.apiKey,
+        events: [amplitudeEvent]
+      };
+      const response = await this.http.post(this.endpoint, body);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `AMPLITUDE_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "AMPLITUDE_UNKNOWN_ERROR", error);
+    }
+  }
+  async page({ name, url, userId, anonymousId, properties }) {
+    return this.track({
+      event: "Page Viewed",
+      properties: {
+        page_name: name,
+        url,
+        ...properties
+      },
+      userId,
+      anonymousId
+    });
+  }
+};
+
+// src/providers/plausible.ts
+var PLAUSIBLE_ENDPOINT = "https://plausible.io/api/event";
+var PlausibleProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "plausible";
+    this.config = config;
+    this.http = createHttpClient();
+    this.endpoint = config.apiUrl ?? PLAUSIBLE_ENDPOINT;
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.userAgent) {
+      headers["User-Agent"] = this.config.userAgent;
+    }
+    if (this.config.xForwardedFor) {
+      headers["X-Forwarded-For"] = this.config.xForwardedFor;
+    }
+    return headers;
+  }
+  async track({ event, properties, context }) {
+    try {
+      const url = context?.page?.url ?? "";
+      const body = {
+        name: event,
+        url,
+        domain: this.config.domain,
+        props: properties
+      };
+      const response = await this.http.post(this.endpoint, body, {
+        headers: this.buildHeaders()
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `PLAUSIBLE_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "PLAUSIBLE_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify(_options) {
+    return {
+      provider: this.name,
+      success: false,
+      error: {
+        message: "Plausible does not support user identification",
+        code: "PLAUSIBLE_NOT_SUPPORTED",
+        provider: this.name
+      }
+    };
+  }
+  async page({ name, url, properties }) {
+    try {
+      const body = {
+        name: "pageview",
+        url,
+        domain: this.config.domain,
+        props: {
+          page_name: name,
+          ...properties
+        }
+      };
+      const response = await this.http.post(this.endpoint, body, {
+        headers: this.buildHeaders()
+      });
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `PLAUSIBLE_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "PLAUSIBLE_UNKNOWN_ERROR", error);
+    }
+  }
+};
+
+// src/providers/posthog.ts
+var POSTHOG_ENDPOINT = "https://app.posthog.com/capture/";
+var PostHogProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "posthog";
+    this.config = config;
+    this.http = createHttpClient();
+    this.endpoint = config.apiUrl ?? POSTHOG_ENDPOINT;
+  }
+  async track({ event, properties, userId, anonymousId, timestamp }) {
+    try {
+      const distinctId = userId ?? anonymousId ?? "anonymous";
+      const body = {
+        api_key: this.config.apiKey,
+        event,
+        distinct_id: distinctId,
+        properties: properties ?? {}
+      };
+      if (timestamp) {
+        body["timestamp"] = timestamp.toISOString();
+      }
+      const response = await this.http.post(this.endpoint, body);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `POSTHOG_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "POSTHOG_UNKNOWN_ERROR", error);
+    }
+  }
+  async identify({ userId, traits }) {
+    try {
+      const body = {
+        api_key: this.config.apiKey,
+        event: "$identify",
+        distinct_id: userId,
+        properties: {
+          $set: traits ?? {}
+        }
+      };
+      const response = await this.http.post(this.endpoint, body);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `POSTHOG_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "POSTHOG_UNKNOWN_ERROR", error);
+    }
+  }
+  async page({ name, url, userId, anonymousId, properties }) {
+    return this.track({
+      event: "$pageview",
+      properties: {
+        $current_url: url,
+        page_name: name,
+        ...properties
+      },
+      userId,
+      anonymousId
+    });
+  }
+};
+
+// src/providers/vercel-analytics.ts
+var VERCEL_ENDPOINT = "https://vitals.vercel-insights.com/v1/vitals";
+function generateId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function flattenProps(props) {
+  const result = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      result[key] = value;
+    } else {
+      result[key] = String(value);
+    }
+  }
+  return result;
+}
+var VercelAnalyticsProvider = class extends BaseProvider {
+  constructor(config) {
+    super();
+    this.name = "vercel-analytics";
+    this.config = config;
+    this.http = createHttpClient();
+    this.endpoint = config.apiUrl ?? VERCEL_ENDPOINT;
+  }
+  async track({ event, properties, timestamp, context }) {
+    try {
+      const url = context?.page?.url ?? "";
+      const payload = {
+        dsn: this.config.analyticsId,
+        id: generateId(),
+        type: "custom",
+        name: event,
+        url,
+        ts: timestamp ? timestamp.getTime() : Date.now()
+      };
+      if (properties && Object.keys(properties).length > 0) {
+        payload.data = flattenProps(properties);
+      }
+      const response = await this.http.post(this.endpoint, payload);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `VERCEL_ANALYTICS_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "VERCEL_ANALYTICS_UNKNOWN_ERROR", error);
+    }
+  }
+  /**
+   * Vercel Analytics is privacy-focused and does not support traditional user
+   * identification. This method returns an unsupported error.
+   */
+  async identify(_options) {
+    return {
+      provider: this.name,
+      success: false,
+      error: {
+        message: "Vercel Analytics does not support user identification",
+        code: "VERCEL_ANALYTICS_NOT_SUPPORTED",
+        provider: this.name
+      }
+    };
+  }
+  async page({ name, url, referrer, properties, timestamp }) {
+    try {
+      const payload = {
+        dsn: this.config.analyticsId,
+        id: generateId(),
+        type: "pageview",
+        name: name ?? "pageview",
+        url,
+        ts: timestamp ? timestamp.getTime() : Date.now()
+      };
+      if (referrer) {
+        payload.referrer = referrer;
+      }
+      if (properties && Object.keys(properties).length > 0) {
+        return this.track({
+          event: name ?? "pageview",
+          properties,
+          context: { page: { url, referrer } },
+          timestamp
+        });
+      }
+      const response = await this.http.post(this.endpoint, payload);
+      return this.buildSuccess(response.status);
+    } catch (error) {
+      if (isAxiosError(error)) {
+        return this.buildError(
+          error.message,
+          `VERCEL_ANALYTICS_HTTP_${error.response?.status ?? "ERROR"}`,
+          error
+        );
+      }
+      return this.buildError(String(error), "VERCEL_ANALYTICS_UNKNOWN_ERROR", error);
+    }
+  }
+};
+
+// src/mytart.ts
+function createProvider(config) {
+  switch (config.provider) {
+    case "google-analytics":
+      return new GoogleAnalyticsProvider(config);
+    case "mixpanel":
+      return new MixpanelProvider(config);
+    case "segment":
+      return new SegmentProvider(config);
+    case "amplitude":
+      return new AmplitudeProvider(config);
+    case "plausible":
+      return new PlausibleProvider(config);
+    case "posthog":
+      return new PostHogProvider(config);
+    case "vercel-analytics":
+      return new VercelAnalyticsProvider(config);
+    default: {
+      const exhaustive = config;
+      throw new Error(`Unknown provider: ${exhaustive.provider}`);
+    }
+  }
+}
+var Mytart = class {
+  constructor(config) {
+    this.config = config;
+    this.providers = config.providers.filter((c) => c.enabled === true).map(createProvider);
+  }
+  async track(options) {
+    const enriched = {
+      userId: this.config.defaultUserId,
+      anonymousId: this.config.defaultAnonymousId,
+      ...options
+    };
+    return Promise.all(this.providers.map((p) => p.track(enriched)));
+  }
+  async identify(options) {
+    return Promise.all(this.providers.map((p) => p.identify(options)));
+  }
+  async page(options) {
+    const enriched = {
+      userId: this.config.defaultUserId,
+      anonymousId: this.config.defaultAnonymousId,
+      ...options
+    };
+    return Promise.all(this.providers.map((p) => p.page(enriched)));
+  }
+  addProvider(config) {
+    if (config.enabled !== true) return;
+    this.providers.push(createProvider(config));
+  }
+  removeProvider(name) {
+    const index = this.providers.findIndex((p) => p.name === name);
+    if (index !== -1) {
+      this.providers.splice(index, 1);
+    }
+  }
+  getProviders() {
+    return this.providers.map((p) => p.name);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmplitudeProvider,
+  BaseProvider,
+  GoogleAnalyticsProvider,
+  MixpanelProvider,
+  Mytart,
+  PlausibleProvider,
+  PostHogProvider,
+  SegmentProvider,
+  VercelAnalyticsProvider
+});