memorysync-sdk 1.0.2 → 1.1.1

package/dist/index.mjs

@@ -1,45 +1,473 @@
-// src/index.ts
+// src/errors.ts
 var MemorySyncError = class extends Error {
-  constructor(message, opts = {}) {
+  constructor(message, options = {}) {
     super(message);
     this.name = "MemorySyncError";
-    this.statusCode = opts.statusCode;
-    this.response = opts.response;
-    this.requestId = opts.requestId;
+    this.statusCode = options.statusCode;
+    this.response = options.response;
+    this.requestId = options.requestId;
   }
 };
 var AuthError = class extends MemorySyncError {
-  constructor(message, opts) {
-    super(message, opts);
+  constructor(message, options) {
+    super(message, options);
     this.name = "AuthError";
   }
 };
 var ValidationError = class extends MemorySyncError {
-  constructor(message, opts) {
-    super(message, opts);
+  constructor(message, options) {
+    super(message, options);
     this.name = "ValidationError";
   }
 };
 var NotFoundError = class extends MemorySyncError {
-  constructor(message, opts) {
-    super(message, opts);
+  constructor(message, options) {
+    super(message, options);
     this.name = "NotFoundError";
   }
 };
 var RateLimitError = class extends MemorySyncError {
-  constructor(message, retryAfterSeconds, opts) {
-    super(message, opts);
+  constructor(message, retryAfterSeconds, options) {
+    super(message, options);
     this.name = "RateLimitError";
     this.retryAfterSeconds = retryAfterSeconds;
   }
 };
 var ServerError = class extends MemorySyncError {
-  constructor(message, opts) {
-    super(message, opts);
+  constructor(message, options) {
+    super(message, options);
     this.name = "ServerError";
   }
 };
-var SDK_VERSION = "1.0.1";
+
+// src/control-plane.ts
+var SDK_VERSION = "1.1.1";
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function extractDetail(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const value = body;
+  if (typeof value.detail === "string") return value.detail;
+  if (value.error && typeof value.error === "object") {
+    const error = value.error;
+    if (typeof error.message === "string") return error.message;
+  }
+  if (Array.isArray(value.detail) && value.detail.length > 0) {
+    const first = value.detail[0];
+    if (first && typeof first === "object" && typeof first.msg === "string") {
+      return first.msg;
+    }
+  }
+  return void 0;
+}
+function extractBodyRetryAfter(body) {
+  if (!body || typeof body !== "object") return 0;
+  const value = body;
+  if (typeof value.retry_after === "number") return value.retry_after;
+  if (value.error && typeof value.error === "object") {
+    const retryAfter = value.error.retry_after;
+    if (typeof retryAfter === "number") return retryAfter;
+  }
+  return 0;
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds;
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+}
+function snakeToCamel(key) {
+  return key.replace(/_([a-z0-9])/g, (_, character) => character.toUpperCase());
+}
+var OPAQUE_RESPONSE_KEYS = /* @__PURE__ */ new Set(["payload", "metadata", "geo", "configuration"]);
+function normalizeResponse(value) {
+  if (Array.isArray(value)) return value.map(normalizeResponse);
+  if (!value || typeof value !== "object") return value;
+  const normalized = {};
+  for (const [key, item] of Object.entries(value)) {
+    const camelKey = snakeToCamel(key);
+    normalized[camelKey] = OPAQUE_RESPONSE_KEYS.has(camelKey) ? item : normalizeResponse(item);
+  }
+  return normalized;
+}
+function queryString(values) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== void 0 && value !== null) params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
+function positiveId(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new ValidationError(`${name} must be a positive integer`);
+  }
+}
+function nonEmpty(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new ValidationError(`${name} must not be empty`);
+}
+function boundedInteger(value, name, minimum, maximum) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new ValidationError(`${name} must be an integer between ${minimum} and ${maximum}`);
+  }
+}
+function nonNegativeInteger(value, name) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new ValidationError(`${name} must be a non-negative integer`);
+  }
+}
+function nonEmptyStrings(values, name) {
+  if (!Array.isArray(values) || values.length === 0 || values.some((value) => typeof value !== "string" || !value.trim())) {
+    throw new ValidationError(`${name} must contain at least one non-empty string`);
+  }
+}
+function webhookRetryConfig(config) {
+  const wire = {};
+  if (config.enabled !== void 0) wire.enabled = config.enabled;
+  if (config.maxRetries !== void 0) wire.max_retries = config.maxRetries;
+  if (config.initialDelaySeconds !== void 0) wire.initial_delay_seconds = config.initialDelaySeconds;
+  if (config.maxDelaySeconds !== void 0) wire.max_delay_seconds = config.maxDelaySeconds;
+  if (config.backoffMultiplier !== void 0) wire.backoff_multiplier = config.backoffMultiplier;
+  if (config.retryStatusCodes !== void 0) wire.retry_status_codes = config.retryStatusCodes;
+  return wire;
+}
+function webhookSignatureConfig(config) {
+  const wire = {};
+  if (config.algorithm !== void 0) wire.algorithm = config.algorithm;
+  if (config.headerName !== void 0) wire.header_name = config.headerName;
+  if (config.timestampHeader !== void 0) wire.timestamp_header = config.timestampHeader;
+  if (config.toleranceSeconds !== void 0) wire.tolerance_seconds = config.toleranceSeconds;
+  return wire;
+}
+function validateWebhook(name, url, events) {
+  nonEmpty(name, "name");
+  if (name.length > 128) throw new ValidationError("name may contain at most 128 characters");
+  nonEmptyStrings(events, "events");
+  validateWebhookUrl(url);
+}
+function validateWebhookUrl(url) {
+  nonEmpty(url, "url");
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ValidationError("url must be a valid HTTP or HTTPS URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ValidationError("url must be a valid HTTP or HTTPS URL");
+  }
+  if (parsed.username || parsed.password) throw new ValidationError("url must not contain credentials");
+}
+var ControlPlaneClient = class {
+  constructor(config) {
+    if (!config.baseUrl?.trim()) throw new ValidationError("baseUrl is required");
+    let parsed;
+    try {
+      parsed = new URL(config.baseUrl);
+    } catch {
+      throw new ValidationError("baseUrl must be an absolute HTTP or HTTPS URL");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new ValidationError("baseUrl must be an absolute HTTP or HTTPS URL");
+    }
+    if (config.accessToken !== void 0 && !config.accessToken.trim()) {
+      throw new ValidationError("accessToken must not be empty when provided");
+    }
+    if (config.projectId !== void 0 && !config.projectId.trim()) {
+      throw new ValidationError("projectId must not be empty when provided");
+    }
+    if (config.timeoutMs !== void 0 && (!Number.isFinite(config.timeoutMs) || config.timeoutMs <= 0)) {
+      throw new ValidationError("timeoutMs must be greater than zero");
+    }
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.accessToken = config.accessToken?.trim();
+    this.projectId = config.projectId?.trim();
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    const implementation = config.fetch ?? (typeof fetch !== "undefined" ? fetch : void 0);
+    if (!implementation) {
+      throw new Error("No fetch implementation available. Pass `fetch` in config or use Node 18+.");
+    }
+    this.fetchImpl = implementation;
+  }
+  async request(method, path, options = {}) {
+    const requiresAuth = options.auth !== false;
+    if (requiresAuth && !this.accessToken) {
+      throw new AuthError("accessToken is required for this operation");
+    }
+    if (options.projectId !== void 0 && !options.projectId.trim()) {
+      throw new ValidationError("projectId override must not be empty");
+    }
+    const headers = {
+      Accept: "application/json",
+      "User-Agent": `memorysync-sdk-js/${SDK_VERSION}`
+    };
+    if (requiresAuth) headers.Authorization = `Bearer ${this.accessToken}`;
+    const selectedProject = options.projectId?.trim() ?? this.projectId;
+    if (selectedProject) headers["X-Project-ID"] = selectedProject;
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal: controller.signal
+      });
+      const requestId = response.headers.get("X-Request-ID") ?? void 0;
+      if (response.status === 204) return void 0;
+      const text = await response.text();
+      const parsedBody = text ? safeJson(text) : null;
+      if (!response.ok) {
+        this.throwForStatus(response.status, parsedBody, requestId, response.headers.get("Retry-After"));
+      }
+      return normalizeResponse(parsedBody);
+    } catch (error) {
+      if (error instanceof MemorySyncError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new MemorySyncError(`Request timed out after ${this.timeoutMs}ms`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new MemorySyncError(`Network error: ${message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throwForStatus(status, body, requestId, retryAfterHeader) {
+    const detail = extractDetail(body);
+    const options = { statusCode: status, response: body, requestId };
+    if (status === 401) throw new AuthError(detail || "Unauthenticated", options);
+    if (status === 403) throw new AuthError(detail || "Forbidden", options);
+    if (status === 404) throw new NotFoundError(detail || "Not found", options);
+    if (status === 400 || status === 409 || status === 422) {
+      throw new ValidationError(detail || "Validation error", options);
+    }
+    if (status === 429) {
+      const retryAfter = parseRetryAfter(retryAfterHeader) ?? extractBodyRetryAfter(body);
+      throw new RateLimitError(detail || "Rate limited", retryAfter, options);
+    }
+    if (status >= 500) throw new ServerError(detail || `Server error (${status})`, options);
+    throw new MemorySyncError(detail || `Unexpected status ${status}`, options);
+  }
+  async bulkRevokeApiKeys(request, options = {}) {
+    if (!Array.isArray(request.keyIds) || request.keyIds.length < 1 || request.keyIds.length > 100) {
+      throw new ValidationError("keyIds must contain between 1 and 100 entries");
+    }
+    request.keyIds.forEach((id) => positiveId(id, "keyIds entry"));
+    return this.request("POST", "/org/api-keys/bulk-revoke", {
+      ...options,
+      body: { key_ids: request.keyIds }
+    });
+  }
+  async testApiKey(keyId, options = {}) {
+    positiveId(keyId, "keyId");
+    return this.request("POST", `/org/api-keys/${keyId}/test`, options);
+  }
+  async login(request, options = {}) {
+    nonEmpty(request.email, "email");
+    nonEmpty(request.password, "password");
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(request.email)) {
+      throw new ValidationError("email must be a valid email address");
+    }
+    return this.request("POST", "/auth/login", {
+      ...options,
+      auth: false,
+      body: { email: request.email, password: request.password }
+    });
+  }
+  async getCurrentPlan(options = {}) {
+    return this.request("GET", "/org/billing/current-plan", options);
+  }
+  async listTeamMembers(options = {}) {
+    return this.request("GET", "/admin/team/members", options);
+  }
+  async suspendTeamMember(memberId, options = {}) {
+    positiveId(memberId, "memberId");
+    return this.request("PATCH", `/admin/team/members/${memberId}`, {
+      ...options,
+      body: { status: "suspended" }
+    });
+  }
+  async removeTeamMember(memberId, options = {}) {
+    positiveId(memberId, "memberId");
+    return this.request("DELETE", `/admin/team/members/${memberId}`, options);
+  }
+  async listSessions(options = {}) {
+    return this.request("GET", "/auth/sessions", options);
+  }
+  async revokeSession(sessionId, options = {}) {
+    positiveId(sessionId, "sessionId");
+    return this.request("POST", `/auth/sessions/${sessionId}/revoke`, options);
+  }
+  async listAuditEvents(query = {}, options = {}) {
+    if (query.limit !== void 0) boundedInteger(query.limit, "limit", 1, 200);
+    if (query.cursor !== void 0) nonNegativeInteger(query.cursor, "cursor");
+    if (query.skip !== void 0) nonNegativeInteger(query.skip, "skip");
+    if (query.sortDirection !== void 0 && query.sortDirection !== "asc" && query.sortDirection !== "desc") {
+      throw new ValidationError("sortDirection must be 'asc' or 'desc'");
+    }
+    const path = "/admin/audit-logs" + queryString({
+      limit: query.limit,
+      cursor: query.cursor,
+      skip: query.skip,
+      sort: query.sortDirection,
+      tenant_id: query.tenantId,
+      actor: query.actor,
+      actor_email: query.actorEmail,
+      ip: query.ip,
+      action: query.action,
+      resource_type: query.resourceType,
+      resource_id: query.resourceId,
+      severity: query.severity,
+      category: query.category,
+      start: query.start,
+      end: query.end,
+      success: query.success,
+      source: query.source,
+      ingest_method: query.ingestMethod,
+      search: query.search,
+      include_stats: query.includeStats
+    });
+    const raw = await this.request("GET", path, options);
+    return {
+      events: raw.logs ?? [],
+      nextCursor: raw.nextCursor ?? null,
+      stats: raw.stats ?? null,
+      sort: raw.sort ?? query.sortDirection ?? "desc"
+    };
+  }
+  async listIntegrations(query = {}, options = {}) {
+    if (query.category !== void 0) nonEmpty(query.category, "category");
+    const path = "/api/v1/integrations/catalog" + queryString({ category: query.category });
+    return this.request("GET", path, options);
+  }
+  async createOrganization(request, options = {}) {
+    nonEmpty(request.name, "name");
+    if (request.domain !== void 0) nonEmpty(request.domain, "domain");
+    const body = { name: request.name };
+    if (request.domain !== void 0) body.domain = request.domain;
+    return this.request("POST", "/organizations", { ...options, body });
+  }
+  async listOrganizations(options = {}) {
+    return this.request("GET", "/organizations", options);
+  }
+  async listOrganizationMembers(options = {}) {
+    return this.listTeamMembers(options);
+  }
+  async getOrganizationSettings(query = {}, options = {}) {
+    if (query.tenantId !== void 0) nonEmpty(query.tenantId, "tenantId");
+    const path = "/admin/tenant-settings" + queryString({ tenant_id: query.tenantId });
+    return this.request("GET", path, options);
+  }
+  async listProjects(options = {}) {
+    return this.request("GET", "/org/projects", options);
+  }
+  async createWebhook(request, options = {}) {
+    validateWebhook(request.name, request.url, request.events);
+    if (request.description !== void 0 && request.description.length > 500) {
+      throw new ValidationError("description may contain at most 500 characters");
+    }
+    if (request.projectId !== void 0) nonEmpty(request.projectId, "projectId");
+    if (options.projectId !== void 0) nonEmpty(options.projectId, "projectId override");
+    if (request.projectId && options.projectId && request.projectId.trim() !== options.projectId.trim()) {
+      throw new ValidationError("request projectId and options projectId must match");
+    }
+    const body = { name: request.name, url: request.url, events: request.events };
+    if (request.description !== void 0) body.description = request.description;
+    if (request.retryConfig !== void 0) body.retry_config = webhookRetryConfig(request.retryConfig);
+    if (request.signatureConfig !== void 0) body.signature_config = webhookSignatureConfig(request.signatureConfig);
+    if (request.projectId !== void 0) body.project_id = request.projectId;
+    return this.request("POST", "/org/webhooks", {
+      ...options,
+      projectId: options.projectId ?? request.projectId,
+      body
+    });
+  }
+  async listWebhooks(options = {}) {
+    return this.request("GET", "/org/webhooks", options);
+  }
+  async updateWebhook(endpointId, request, options = {}) {
+    positiveId(endpointId, "endpointId");
+    const body = {};
+    if (request.name !== void 0) {
+      nonEmpty(request.name, "name");
+      if (request.name.length > 128) throw new ValidationError("name may contain at most 128 characters");
+      body.name = request.name;
+    }
+    if (request.url !== void 0) {
+      validateWebhookUrl(request.url);
+      body.url = request.url;
+    }
+    if (request.description !== void 0) {
+      if (request.description.length > 500) {
+        throw new ValidationError("description may contain at most 500 characters");
+      }
+      body.description = request.description;
+    }
+    if (request.events !== void 0) {
+      nonEmptyStrings(request.events, "events");
+      body.events = request.events;
+    }
+    if (request.retryConfig !== void 0) body.retry_config = webhookRetryConfig(request.retryConfig);
+    if (request.signatureConfig !== void 0) body.signature_config = webhookSignatureConfig(request.signatureConfig);
+    if (Object.keys(body).length === 0) {
+      throw new ValidationError("updateWebhook requires at least one editable field");
+    }
+    return this.request("PATCH", `/org/webhooks/${endpointId}`, { ...options, body });
+  }
+  async deleteWebhook(endpointId, options = {}) {
+    positiveId(endpointId, "endpointId");
+    return this.request("DELETE", `/org/webhooks/${endpointId}`, options);
+  }
+  async testWebhook(endpointId, request = {}, options = {}) {
+    positiveId(endpointId, "endpointId");
+    const body = {};
+    if (request.eventType !== void 0) {
+      nonEmpty(request.eventType, "eventType");
+      body.event_type = request.eventType;
+    }
+    return this.request("POST", `/org/webhooks/${endpointId}/test`, { ...options, body });
+  }
+  async replayWebhookDeliveries(endpointId, request = {}, options = {}) {
+    positiveId(endpointId, "endpointId");
+    if (request.sinceMinutes !== void 0 && (!Number.isInteger(request.sinceMinutes) || request.sinceMinutes < 1 || request.sinceMinutes > 10080)) {
+      throw new ValidationError("sinceMinutes must be an integer between 1 and 10080");
+    }
+    if (request.limit !== void 0 && (!Number.isInteger(request.limit) || request.limit < 1 || request.limit > 1e3)) {
+      throw new ValidationError("limit must be an integer between 1 and 1000");
+    }
+    if (request.statuses !== void 0) nonEmptyStrings(request.statuses, "statuses");
+    const body = {};
+    if (request.sinceMinutes !== void 0) body.since_minutes = request.sinceMinutes;
+    if (request.statuses !== void 0) body.statuses = request.statuses;
+    if (request.limit !== void 0) body.limit = request.limit;
+    return this.request("POST", `/org/webhooks/${endpointId}/replay`, { ...options, body });
+  }
+  async listWebhookDeliveries(endpointId, query = {}, options = {}) {
+    positiveId(endpointId, "endpointId");
+    if (query.page !== void 0) positiveId(query.page, "page");
+    if (query.pageSize !== void 0 && (!Number.isInteger(query.pageSize) || query.pageSize < 1 || query.pageSize > 100)) {
+      throw new ValidationError("pageSize must be an integer between 1 and 100");
+    }
+    if (query.status !== void 0) nonEmpty(query.status, "status");
+    const path = `/org/webhooks/${endpointId}/deliveries` + queryString({
+      page: query.page,
+      page_size: query.pageSize,
+      status_filter: query.status
+    });
+    return this.request("GET", path, options);
+  }
+};
+
+// src/index.ts
+var SDK_VERSION2 = "1.1.0";
 function camelToSnakeKey(key) {
   return key.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
@@ -68,14 +496,14 @@ function snakeToCamelMemory(m) {
     score: m.score ?? null
   };
 }
-function safeJson(text) {
+function safeJson2(text) {
   try {
     return JSON.parse(text);
   } catch {
     return text;
   }
 }
-function extractDetail(body) {
+function extractDetail2(body) {
   if (!body || typeof body !== "object") return void 0;
   const b = body;
   if (typeof b.detail === "string") return b.detail;
@@ -119,7 +547,7 @@ var MemorySyncClient = class {
       "X-API-Key": this.apiKey,
       "Content-Type": "application/json",
       "Accept": "application/json",
-      "User-Agent": `memorysync-sdk-js/${SDK_VERSION}`,
+      "User-Agent": `memorysync-sdk-js/${SDK_VERSION2}`,
       ...extra
     };
     if (this.projectId) h["X-Project-ID"] = this.projectId;
@@ -143,7 +571,7 @@ var MemorySyncClient = class {
       const requestId = res.headers.get("X-Request-ID") ?? void 0;
       if (res.status === 204) return void 0;
       const text = await res.text();
-      const parsed = text ? safeJson(text) : null;
+      const parsed = text ? safeJson2(text) : null;
       if (!res.ok) this.throwForStatus(res.status, parsed, requestId);
       return parsed;
     } catch (e) {
@@ -157,7 +585,7 @@ var MemorySyncClient = class {
     }
   }
   throwForStatus(status, body, requestId) {
-    const detail = extractDetail(body);
+    const detail = extractDetail2(body);
     const opts = { statusCode: status, response: body, requestId };
     if (status === 401) throw new AuthError(detail || "Unauthenticated", opts);
     if (status === 403) throw new AuthError(detail || "Forbidden", opts);
@@ -332,6 +760,7 @@ var MemorySyncClient = class {
 };
 export {
   AuthError,
+  ControlPlaneClient,
   MemorySyncClient,
   MemorySyncError,
   NotFoundError,