@contractspec/integration.providers-impls 1.56.1 → 1.58.0

package/dist/impls/posthog.js

@@ -0,0 +1,323 @@
+// @bun
+// src/impls/posthog-reader.ts
+class PosthogAnalyticsReader {
+  projectId;
+  client;
+  constructor(options) {
+    this.projectId = options.projectId;
+    this.client = options.client;
+  }
+  async queryHogQL(input) {
+    const projectId = resolveProjectId(undefined, this.projectId);
+    const response = await this.client.request({
+      method: "POST",
+      path: `/api/projects/${projectId}/query`,
+      body: {
+        query: {
+          kind: "HogQLQuery",
+          query: input.query,
+          values: input.values
+        }
+      }
+    });
+    return response.data;
+  }
+  async getEvents(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/events/`,
+      query: {
+        event: input.event ?? resolveSingleEvent(input.events),
+        events: resolveEventList(input.events),
+        distinct_id: input.distinctId,
+        order_by: input.orderBy,
+        limit: input.limit,
+        offset: input.offset,
+        properties: input.properties ? JSON.stringify(input.properties) : undefined,
+        ...buildEventDateQuery(input.dateRange)
+      }
+    });
+    return response.data;
+  }
+  async getPersons(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/persons/`,
+      query: {
+        cohort_id: input.cohortId,
+        search: input.search,
+        limit: input.limit,
+        offset: input.offset,
+        properties: input.properties ? JSON.stringify(input.properties) : undefined
+      }
+    });
+    return response.data;
+  }
+  async getInsights(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/insights/`,
+      query: {
+        insight: input.insightType,
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getInsightResult(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/insights/${input.insightId}/`
+    });
+    return response.data;
+  }
+  async getCohorts(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/cohorts/`,
+      query: {
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getFeatureFlags(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/feature_flags/`,
+      query: {
+        active: input.active,
+        limit: input.limit,
+        offset: input.offset
+      }
+    });
+    return response.data;
+  }
+  async getAnnotations(input) {
+    const projectId = resolveProjectId(input.projectId, this.projectId);
+    const response = await this.client.request({
+      method: "GET",
+      path: `/api/projects/${projectId}/annotations/`,
+      query: {
+        limit: input.limit,
+        offset: input.offset,
+        ...buildAnnotationDateQuery(input.dateRange)
+      }
+    });
+    return response.data;
+  }
+}
+function resolveProjectId(inputProjectId, defaultProjectId) {
+  const projectId = inputProjectId ?? defaultProjectId;
+  if (!projectId) {
+    throw new Error("PostHog projectId is required for API reads.");
+  }
+  return projectId;
+}
+function resolveSingleEvent(events) {
+  if (!events || events.length !== 1)
+    return;
+  return events[0];
+}
+function resolveEventList(events) {
+  if (!events || events.length <= 1)
+    return;
+  return events.join(",");
+}
+function buildEventDateQuery(range) {
+  const after = formatDate(range?.from);
+  const before = formatDate(range?.to);
+  return {
+    after,
+    before,
+    timezone: range?.timezone
+  };
+}
+function buildAnnotationDateQuery(range) {
+  const dateFrom = formatDate(range?.from);
+  const dateTo = formatDate(range?.to);
+  return {
+    date_from: dateFrom,
+    date_to: dateTo,
+    timezone: range?.timezone
+  };
+}
+function formatDate(value) {
+  if (!value)
+    return;
+  return typeof value === "string" ? value : value.toISOString();
+}
+
+// src/impls/posthog-utils.ts
+function normalizeHost(host) {
+  return host.replace(/\/$/, "");
+}
+function buildUrl(host, path, query) {
+  if (/^https?:\/\//.test(path)) {
+    return appendQuery(path, query);
+  }
+  const normalizedPath = path.replace(/^\/+/, "");
+  return appendQuery(`${host}/${normalizedPath}`, query);
+}
+function appendQuery(url, query) {
+  if (!query)
+    return url;
+  const params = new URLSearchParams;
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === undefined)
+      return;
+    params.set(key, String(value));
+  });
+  const suffix = params.toString();
+  return suffix ? `${url}?${suffix}` : url;
+}
+function parseJson(value) {
+  if (!value)
+    return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/impls/posthog.ts
+import { PostHog } from "posthog-node";
+var DEFAULT_POSTHOG_HOST = "https://app.posthog.com";
+
+class PosthogAnalyticsProvider {
+  host;
+  projectId;
+  projectApiKey;
+  personalApiKey;
+  mcpUrl;
+  fetchFn;
+  client;
+  reader;
+  constructor(options) {
+    this.host = normalizeHost(options.host ?? DEFAULT_POSTHOG_HOST);
+    this.projectId = options.projectId;
+    this.projectApiKey = options.projectApiKey;
+    this.personalApiKey = options.personalApiKey;
+    this.mcpUrl = options.mcpUrl;
+    this.fetchFn = options.fetch ?? fetch;
+    this.client = options.client ?? (options.projectApiKey ? new PostHog(options.projectApiKey, {
+      host: this.host,
+      requestTimeout: options.requestTimeoutMs ?? 1e4
+    }) : undefined);
+    this.reader = new PosthogAnalyticsReader({
+      projectId: this.projectId,
+      client: { request: this.request.bind(this) }
+    });
+  }
+  async capture(event) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for capture.");
+    }
+    await this.client.capture({
+      distinctId: event.distinctId,
+      event: event.event,
+      properties: event.properties,
+      timestamp: event.timestamp,
+      groups: event.groups
+    });
+  }
+  async identify(input) {
+    if (!this.client) {
+      throw new Error("PostHog projectApiKey is required for identify.");
+    }
+    await this.client.identify({
+      distinctId: input.distinctId,
+      properties: {
+        ...input.properties ? { $set: input.properties } : {},
+        ...input.setOnce ? { $set_once: input.setOnce } : {}
+      }
+    });
+  }
+  async queryHogQL(input) {
+    return this.reader.queryHogQL(input);
+  }
+  async getEvents(input) {
+    return this.reader.getEvents(input);
+  }
+  async getPersons(input) {
+    return this.reader.getPersons(input);
+  }
+  async getInsights(input) {
+    return this.reader.getInsights(input);
+  }
+  async getInsightResult(input) {
+    return this.reader.getInsightResult(input);
+  }
+  async getCohorts(input) {
+    return this.reader.getCohorts(input);
+  }
+  async getFeatureFlags(input) {
+    return this.reader.getFeatureFlags(input);
+  }
+  async getAnnotations(input) {
+    return this.reader.getAnnotations(input);
+  }
+  async request(request) {
+    if (!this.personalApiKey) {
+      throw new Error("PostHog personalApiKey is required for API requests.");
+    }
+    const url = buildUrl(this.host, request.path, request.query);
+    const response = await this.fetchFn(url, {
+      method: request.method,
+      headers: {
+        Authorization: `Bearer ${this.personalApiKey}`,
+        "Content-Type": "application/json",
+        ...request.headers ?? {}
+      },
+      body: request.body ? JSON.stringify(request.body) : undefined
+    });
+    const text = await response.text();
+    const data = parseJson(text);
+    return {
+      status: response.status,
+      data,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+  }
+  async callMcpTool(call) {
+    if (!this.mcpUrl) {
+      throw new Error("PostHog MCP URL is not configured.");
+    }
+    const response = await this.fetchFn(this.mcpUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: call.name,
+          arguments: call.arguments ?? {}
+        }
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`PostHog MCP error (${response.status}): ${body}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message ?? "PostHog MCP error");
+    }
+    return result.result ?? null;
+  }
+}
+export {
+  PosthogAnalyticsProvider
+};

package/dist/impls/postmark-email.d.ts

@@ -1,20 +1,16 @@
-import { email_d_exports } from "../email.js";
-import { ServerClient } from "postmark";
-
-//#region src/impls/postmark-email.d.ts
-interface PostmarkEmailProviderOptions {
-  serverToken: string;
-  defaultFromEmail?: string;
-  messageStream?: string;
-  client?: ServerClient;
+import { ServerClient } from 'postmark';
+import type { EmailOutboundMessage, EmailOutboundProvider, EmailOutboundResult } from '../email';
+export interface PostmarkEmailProviderOptions {
+    serverToken: string;
+    defaultFromEmail?: string;
+    messageStream?: string;
+    client?: ServerClient;
 }
-declare class PostmarkEmailProvider implements email_d_exports.EmailOutboundProvider {
-  private readonly client;
-  private readonly defaultFromEmail?;
-  private readonly messageStream?;
-  constructor(options: PostmarkEmailProviderOptions);
-  sendEmail(message: email_d_exports.EmailOutboundMessage): Promise<email_d_exports.EmailOutboundResult>;
+export declare class PostmarkEmailProvider implements EmailOutboundProvider {
+    private readonly client;
+    private readonly defaultFromEmail?;
+    private readonly messageStream?;
+    constructor(options: PostmarkEmailProviderOptions);
+    sendEmail(message: EmailOutboundMessage): Promise<EmailOutboundResult>;
 }
-//#endregion
-export { PostmarkEmailProvider, PostmarkEmailProviderOptions };
 //# sourceMappingURL=postmark-email.d.ts.map

package/dist/impls/postmark-email.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postmark-email.d.ts","names":[],"sources":["../../src/impls/postmark-email.ts"],"sourcesContent":[],"mappings":";;;;UAQiB,4BAAA;;EAAA,gBAAA,CAAA,EAAA,MAAA;EAOJ,aAAA,CAAA,EAAA,MAAA;EAKU,MAAA,CAAA,EARZ,YAQY;;AAUmC,cAf7C,qBAAA,YAAiC,eAAA,CAAA,qBAeY,CAAA;EAAR,iBAAA,MAAA;EAfJ,iBAAA,gBAAA;EAAqB,iBAAA,aAAA;uBAK5C;qBAUI,eAAA,CAAA,uBAAuB,QAAQ,eAAA,CAAA"}
+{"version":3,"file":"postmark-email.d.ts","sourceRoot":"","sources":["../../src/impls/postmark-email.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAiC,MAAM,UAAU,CAAC;AAEvE,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,qBAAa,qBAAsB,YAAW,qBAAqB;IACjE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAS;gBAE5B,OAAO,EAAE,4BAA4B;IAU3C,SAAS,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA6B7E"}

package/dist/impls/postmark-email.js

@@ -1,56 +1,61 @@
+// @bun
+// src/impls/postmark-email.ts
 import { ServerClient } from "postmark";
 
-//#region src/impls/postmark-email.ts
-var PostmarkEmailProvider = class {
-	client;
-	defaultFromEmail;
-	messageStream;
-	constructor(options) {
-		this.client = options.client ?? new ServerClient(options.serverToken, { useHttps: true });
-		this.defaultFromEmail = options.defaultFromEmail;
-		this.messageStream = options.messageStream;
-	}
-	async sendEmail(message) {
-		const request = {
-			From: formatAddress(message.from) ?? this.defaultFromEmail,
-			To: message.to.map((addr) => formatAddress(addr)).join(", "),
-			Cc: message.cc?.map((addr) => formatAddress(addr)).join(", ") || void 0,
-			Bcc: message.bcc?.map((addr) => formatAddress(addr)).join(", ") || void 0,
-			ReplyTo: message.replyTo ? formatAddress(message.replyTo) : void 0,
-			Subject: message.subject,
-			TextBody: message.textBody,
-			HtmlBody: message.htmlBody,
-			Headers: message.headers ? Object.entries(message.headers).map(([name, value]) => ({
-				Name: name,
-				Value: value
-			})) : void 0,
-			MessageStream: this.messageStream,
-			Attachments: buildAttachments(message)
-		};
-		const response = await this.client.sendEmail(request);
-		return {
-			id: response.MessageID,
-			providerMessageId: response.MessageID,
-			queuedAt: new Date(response.SubmittedAt ?? (/* @__PURE__ */ new Date()).toISOString())
-		};
-	}
-};
+class PostmarkEmailProvider {
+  client;
+  defaultFromEmail;
+  messageStream;
+  constructor(options) {
+    this.client = options.client ?? new ServerClient(options.serverToken, {
+      useHttps: true
+    });
+    this.defaultFromEmail = options.defaultFromEmail;
+    this.messageStream = options.messageStream;
+  }
+  async sendEmail(message) {
+    const request = {
+      From: formatAddress(message.from) ?? this.defaultFromEmail,
+      To: message.to.map((addr) => formatAddress(addr)).join(", "),
+      Cc: message.cc?.map((addr) => formatAddress(addr)).join(", ") || undefined,
+      Bcc: message.bcc?.map((addr) => formatAddress(addr)).join(", ") || undefined,
+      ReplyTo: message.replyTo ? formatAddress(message.replyTo) : undefined,
+      Subject: message.subject,
+      TextBody: message.textBody,
+      HtmlBody: message.htmlBody,
+      Headers: message.headers ? Object.entries(message.headers).map(([name, value]) => ({
+        Name: name,
+        Value: value
+      })) : undefined,
+      MessageStream: this.messageStream,
+      Attachments: buildAttachments(message)
+    };
+    const response = await this.client.sendEmail(request);
+    return {
+      id: response.MessageID,
+      providerMessageId: response.MessageID,
+      queuedAt: new Date(response.SubmittedAt ?? new Date().toISOString())
+    };
+  }
+}
 function formatAddress(address) {
-	if (address.name) return `"${address.name}" <${address.email}>`;
-	return address.email;
+  if (address.name) {
+    return `"${address.name}" <${address.email}>`;
+  }
+  return address.email;
 }
 function buildAttachments(message) {
-	if (!message.attachments?.length) return void 0;
-	return message.attachments.filter((attachment) => attachment.data).map((attachment) => ({
-		Name: attachment.filename,
-		Content: Buffer.from(attachment.data ?? new Uint8Array()).toString("base64"),
-		ContentType: attachment.contentType,
-		ContentID: null,
-		ContentLength: attachment.sizeBytes,
-		Disposition: "attachment"
-	}));
+  if (!message.attachments?.length)
+    return;
+  return message.attachments.filter((attachment) => attachment.data).map((attachment) => ({
+    Name: attachment.filename,
+    Content: Buffer.from(attachment.data ?? new Uint8Array).toString("base64"),
+    ContentType: attachment.contentType,
+    ContentID: null,
+    ContentLength: attachment.sizeBytes,
+    Disposition: "attachment"
+  }));
 }
-
-//#endregion
-export { PostmarkEmailProvider };
-//# sourceMappingURL=postmark-email.js.map
+export {
+  PostmarkEmailProvider
+};