@contractspec/integration.providers-impls 1.56.1 → 1.58.0

package/dist/node/impls/supabase-vector.js

@@ -0,0 +1,323 @@
+// src/impls/supabase-psql.ts
+import { Buffer } from "node:buffer";
+import { sql as drizzleSql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+class SupabasePostgresProvider {
+  client;
+  db;
+  ownsClient;
+  createDrizzle;
+  constructor(options = {}) {
+    this.createDrizzle = options.createDrizzle ?? ((client) => drizzle(client));
+    if (options.db) {
+      if (!options.client) {
+        throw new Error("SupabasePostgresProvider requires a postgres client when db is provided.");
+      }
+      this.client = options.client;
+      this.db = options.db;
+      this.ownsClient = false;
+      return;
+    }
+    if (options.client) {
+      this.client = options.client;
+      this.ownsClient = false;
+    } else {
+      if (!options.connectionString) {
+        throw new Error("SupabasePostgresProvider requires either a connectionString or a client.");
+      }
+      this.client = postgres(options.connectionString, {
+        max: options.maxConnections,
+        prepare: false,
+        ssl: resolveSslMode(options.sslMode)
+      });
+      this.ownsClient = true;
+    }
+    this.db = this.createDrizzle(this.client);
+  }
+  async query(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    const result = await this.db.execute(query);
+    const rows = asRows(result);
+    return {
+      rows,
+      rowCount: rows.length
+    };
+  }
+  async execute(statement, params = []) {
+    const query = buildParameterizedSql(statement, params);
+    await this.db.execute(query);
+  }
+  async transaction(run) {
+    const transactionResult = this.client.begin(async (transactionClient) => {
+      const transactionalProvider = new SupabasePostgresProvider({
+        client: transactionClient,
+        db: this.createDrizzle(transactionClient),
+        createDrizzle: this.createDrizzle
+      });
+      return run(transactionalProvider);
+    });
+    return transactionResult;
+  }
+  async close() {
+    if (this.ownsClient) {
+      await this.client.end({ timeout: 5 });
+    }
+  }
+}
+function buildParameterizedSql(statement, params) {
+  const segments = [];
+  const pattern = /\$(\d+)/g;
+  let cursor = 0;
+  for (const match of statement.matchAll(pattern)) {
+    const token = match[0];
+    const indexPart = match[1];
+    const start = match.index;
+    if (indexPart == null || start == null)
+      continue;
+    const parameterIndex = Number(indexPart) - 1;
+    if (!Number.isInteger(parameterIndex) || parameterIndex < 0 || parameterIndex >= params.length) {
+      throw new Error(`SQL placeholder ${token} is out of bounds for ${params.length} parameter(s).`);
+    }
+    const staticSegment = statement.slice(cursor, start);
+    if (staticSegment.length > 0) {
+      segments.push(drizzleSql.raw(staticSegment));
+    }
+    const parameterValue = params[parameterIndex];
+    if (parameterValue === undefined) {
+      throw new Error(`SQL placeholder ${token} is missing a parameter value.`);
+    }
+    const normalizedValue = normalizeParam(parameterValue);
+    segments.push(drizzleSql`${normalizedValue}`);
+    cursor = start + token.length;
+  }
+  const tailSegment = statement.slice(cursor);
+  if (tailSegment.length > 0) {
+    segments.push(drizzleSql.raw(tailSegment));
+  }
+  if (segments.length === 0) {
+    return drizzleSql.raw("");
+  }
+  return drizzleSql.join(segments);
+}
+function normalizeParam(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+  if (isPlainObject(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function asRows(result) {
+  if (!Array.isArray(result)) {
+    return [];
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (value instanceof Uint8Array) {
+    return false;
+  }
+  return true;
+}
+function resolveSslMode(mode) {
+  switch (mode) {
+    case "allow":
+      return false;
+    case "prefer":
+      return "prefer";
+    case "require":
+    default:
+      return "require";
+  }
+}
+
+// src/impls/supabase-vector.ts
+class SupabaseVectorProvider {
+  database;
+  createTableIfMissing;
+  distanceMetric;
+  quotedSchema;
+  qualifiedTable;
+  collectionIndex;
+  namespaceIndex;
+  ensureTablePromise;
+  constructor(options) {
+    this.database = options.database ?? new SupabasePostgresProvider({
+      connectionString: options.connectionString,
+      maxConnections: options.maxConnections,
+      sslMode: options.sslMode
+    });
+    this.createTableIfMissing = options.createTableIfMissing ?? true;
+    this.distanceMetric = options.distanceMetric ?? "cosine";
+    const schema = sanitizeIdentifier(options.schema ?? "public", "schema");
+    const table = sanitizeIdentifier(options.table ?? "contractspec_vectors", "table");
+    this.quotedSchema = quoteIdentifier(schema);
+    this.qualifiedTable = `${this.quotedSchema}.${quoteIdentifier(table)}`;
+    this.collectionIndex = quoteIdentifier(`${table}_collection_idx`);
+    this.namespaceIndex = quoteIdentifier(`${table}_namespace_idx`);
+  }
+  async upsert(request) {
+    if (request.documents.length === 0) {
+      return;
+    }
+    if (this.createTableIfMissing) {
+      await this.ensureTable();
+    }
+    for (const document of request.documents) {
+      await this.database.execute(`INSERT INTO ${this.qualifiedTable}
+          (collection, id, embedding, payload, namespace, expires_at, updated_at)
+         VALUES ($1, $2, $3::vector, $4::jsonb, $5, $6, now())
+         ON CONFLICT (collection, id)
+         DO UPDATE SET
+           embedding = EXCLUDED.embedding,
+           payload = EXCLUDED.payload,
+           namespace = EXCLUDED.namespace,
+           expires_at = EXCLUDED.expires_at,
+           updated_at = now();`, [
+        request.collection,
+        document.id,
+        toVectorLiteral(document.vector),
+        document.payload ? JSON.stringify(document.payload) : null,
+        document.namespace ?? null,
+        document.expiresAt ?? null
+      ]);
+    }
+  }
+  async search(query) {
+    const operator = this.distanceOperator;
+    const results = await this.database.query(`SELECT
+         id,
+         payload,
+         namespace,
+         (embedding ${operator} $3::vector) AS distance
+       FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND ($2::text IS NULL OR namespace = $2)
+         AND (expires_at IS NULL OR expires_at > now())
+         AND ($4::jsonb IS NULL OR payload @> $4::jsonb)
+       ORDER BY embedding ${operator} $3::vector
+       LIMIT $5;`, [
+      query.collection,
+      query.namespace ?? null,
+      toVectorLiteral(query.vector),
+      query.filter ? JSON.stringify(query.filter) : null,
+      query.topK
+    ]);
+    const mapped = results.rows.map((row) => {
+      const distance = Number(row.distance);
+      return {
+        id: row.id,
+        score: distanceToScore(distance, this.distanceMetric),
+        payload: isRecord(row.payload) ? row.payload : undefined,
+        namespace: row.namespace ?? undefined
+      };
+    });
+    const scoreThreshold = query.scoreThreshold;
+    if (scoreThreshold == null) {
+      return mapped;
+    }
+    return mapped.filter((result) => result.score >= scoreThreshold);
+  }
+  async delete(request) {
+    if (request.ids.length === 0) {
+      return;
+    }
+    const params = [
+      request.collection,
+      request.ids,
+      request.namespace ?? null
+    ];
+    await this.database.execute(`DELETE FROM ${this.qualifiedTable}
+       WHERE collection = $1
+         AND id = ANY($2::text[])
+         AND ($3::text IS NULL OR namespace = $3);`, params);
+  }
+  async ensureTable() {
+    if (!this.ensureTablePromise) {
+      this.ensureTablePromise = this.createTable();
+    }
+    await this.ensureTablePromise;
+  }
+  async createTable() {
+    await this.database.execute("CREATE EXTENSION IF NOT EXISTS vector;");
+    await this.database.execute(`CREATE SCHEMA IF NOT EXISTS ${this.quotedSchema};`);
+    await this.database.execute(`CREATE TABLE IF NOT EXISTS ${this.qualifiedTable} (
+         collection text NOT NULL,
+         id text NOT NULL,
+         embedding vector NOT NULL,
+         payload jsonb,
+         namespace text,
+         expires_at timestamptz,
+         created_at timestamptz NOT NULL DEFAULT now(),
+         updated_at timestamptz NOT NULL DEFAULT now(),
+         PRIMARY KEY (collection, id)
+       );`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.collectionIndex}
+         ON ${this.qualifiedTable} (collection);`);
+    await this.database.execute(`CREATE INDEX IF NOT EXISTS ${this.namespaceIndex}
+         ON ${this.qualifiedTable} (namespace);`);
+  }
+  get distanceOperator() {
+    switch (this.distanceMetric) {
+      case "l2":
+        return "<->";
+      case "inner_product":
+        return "<#>";
+      case "cosine":
+      default:
+        return "<=>";
+    }
+  }
+}
+function sanitizeIdentifier(value, label) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new Error(`SupabaseVectorProvider ${label} "${value}" is invalid.`);
+  }
+  return value;
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function toVectorLiteral(vector) {
+  if (vector.length === 0) {
+    throw new Error("Supabase vectors must contain at least one dimension.");
+  }
+  for (const value of vector) {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Supabase vectors must be finite numbers. Found "${value}".`);
+    }
+  }
+  return `[${vector.join(",")}]`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function distanceToScore(distance, metric) {
+  switch (metric) {
+    case "inner_product":
+      return -distance;
+    case "l2":
+      return 1 / (1 + distance);
+    case "cosine":
+    default:
+      return 1 - distance;
+  }
+}
+export {
+  SupabaseVectorProvider
+};

package/dist/node/impls/tldv-meeting-recorder.js

@@ -0,0 +1,145 @@
+// src/impls/tldv-meeting-recorder.ts
+var DEFAULT_BASE_URL = "https://pasta.tldv.io/v1alpha1";
+
+class TldvMeetingRecorderProvider {
+  apiKey;
+  baseUrl;
+  defaultPageSize;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.defaultPageSize = options.pageSize;
+  }
+  async listMeetings(params) {
+    const page = params.cursor ? Number(params.cursor) : 1;
+    const limit = params.pageSize ?? this.defaultPageSize ?? 50;
+    const query = new URLSearchParams;
+    query.set("page", String(Number.isFinite(page) ? page : 1));
+    query.set("limit", String(limit));
+    if (params.query)
+      query.set("query", params.query);
+    if (params.from)
+      query.set("from", params.from);
+    if (params.to)
+      query.set("to", params.to);
+    if (params.organizerEmail)
+      query.set("organizer", params.organizerEmail);
+    if (params.participantEmail)
+      query.set("participant", params.participantEmail);
+    const data = await this.request(`/meetings?${query.toString()}`);
+    const nextPage = data.page < data.pages ? data.page + 1 : undefined;
+    return {
+      meetings: data.results.map((meeting) => this.mapMeeting(meeting, params)),
+      nextCursor: nextPage ? String(nextPage) : undefined,
+      hasMore: Boolean(nextPage)
+    };
+  }
+  async getMeeting(params) {
+    const meeting = await this.request(`/meetings/${encodeURIComponent(params.meetingId)}`);
+    return this.mapMeeting(meeting, params);
+  }
+  async getTranscript(params) {
+    const response = await this.request(`/meetings/${encodeURIComponent(params.meetingId)}/transcript`);
+    const segments = response.data.map((segment, index) => this.mapTranscriptSegment(segment, index));
+    return {
+      id: response.id,
+      meetingId: response.meetingId,
+      tenantId: params.tenantId,
+      connectionId: params.connectionId ?? "unknown",
+      externalId: response.id,
+      format: "segments",
+      text: segments.map((segment) => segment.text).join(`
+`),
+      segments,
+      metadata: {
+        providerMeetingId: response.meetingId
+      },
+      raw: response.data
+    };
+  }
+  async parseWebhook(request) {
+    const payload = request.parsedBody ?? JSON.parse(request.rawBody);
+    const body = payload;
+    return {
+      providerKey: "meeting-recorder.tldv",
+      eventType: body.event,
+      meetingId: body.data?.id ?? body.data?.meetingId,
+      receivedAt: body.executedAt,
+      payload
+    };
+  }
+  mapMeeting(meeting, params) {
+    const connectionId = params.connectionId ?? "unknown";
+    const invitees = meeting.invitees?.map((invitee) => this.mapInvitee(invitee)).filter(Boolean);
+    return {
+      id: meeting.id,
+      tenantId: params.tenantId,
+      connectionId,
+      externalId: meeting.id,
+      title: meeting.name,
+      organizer: this.mapInvitee(meeting.organizer, "organizer"),
+      invitees: invitees?.length ? invitees : undefined,
+      participants: invitees?.length ? invitees : undefined,
+      scheduledStartAt: meeting.happenedAt,
+      recordingStartAt: meeting.happenedAt,
+      durationSeconds: meeting.duration,
+      meetingUrl: meeting.url,
+      transcriptAvailable: true,
+      sourcePlatform: "tldv",
+      metadata: {
+        template: meeting.template,
+        extraProperties: meeting.extraProperties
+      }
+    };
+  }
+  mapInvitee(invitee, role = "attendee") {
+    if (!invitee)
+      return;
+    return {
+      name: invitee.name ?? undefined,
+      email: invitee.email ?? undefined,
+      role
+    };
+  }
+  mapTranscriptSegment(segment, index) {
+    return {
+      index,
+      speakerName: segment.speaker ?? undefined,
+      text: segment.text,
+      startTimeMs: parseSeconds(segment.startTime),
+      endTimeMs: parseSeconds(segment.endTime)
+    };
+  }
+  async request(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      const message = await safeReadError(response);
+      throw new Error(`tl;dv API error (${response.status}): ${message}`);
+    }
+    return await response.json();
+  }
+}
+function parseSeconds(value) {
+  if (value == null)
+    return;
+  const num = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(num))
+    return;
+  return num * 1000;
+}
+async function safeReadError(response) {
+  try {
+    const data = await response.json();
+    return data?.message ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+export {
+  TldvMeetingRecorderProvider
+};

package/dist/node/impls/twilio-sms.js

@@ -0,0 +1,65 @@
+// src/impls/twilio-sms.ts
+import Twilio from "twilio";
+
+class TwilioSmsProvider {
+  client;
+  fromNumber;
+  constructor(options) {
+    this.client = options.client ?? Twilio(options.accountSid, options.authToken);
+    this.fromNumber = options.fromNumber;
+  }
+  async sendSms(input) {
+    const message = await this.client.messages.create({
+      to: input.to,
+      from: input.from ?? this.fromNumber,
+      body: input.body
+    });
+    return {
+      id: message.sid,
+      to: message.to ?? input.to,
+      from: message.from ?? input.from ?? this.fromNumber ?? "",
+      body: message.body ?? input.body,
+      status: mapStatus(message.status),
+      sentAt: message.dateCreated ? new Date(message.dateCreated) : undefined,
+      deliveredAt: message.status === "delivered" && message.dateUpdated ? new Date(message.dateUpdated) : undefined,
+      price: message.price ? Number(message.price) : undefined,
+      priceCurrency: message.priceUnit ?? undefined,
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined
+    };
+  }
+  async getDeliveryStatus(messageId) {
+    const message = await this.client.messages(messageId).fetch();
+    return {
+      status: mapStatus(message.status),
+      errorCode: message.errorCode ? String(message.errorCode) : undefined,
+      errorMessage: message.errorMessage ?? undefined,
+      updatedAt: message.dateUpdated ? new Date(message.dateUpdated) : new Date
+    };
+  }
+}
+function mapStatus(status) {
+  switch (status) {
+    case "queued":
+    case "accepted":
+    case "scheduled":
+      return "queued";
+    case "sending":
+    case "processing":
+      return "sending";
+    case "sent":
+      return "sent";
+    case "delivered":
+      return "delivered";
+    case "undelivered":
+      return "undelivered";
+    case "failed":
+    case "canceled":
+      return "failed";
+    default:
+      return "queued";
+  }
+}
+export {
+  TwilioSmsProvider
+};