@vettly/supabase 0.1.0

package/dist/index.cjs

@@ -0,0 +1,402 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VettlyAuthError: () => VettlyAuthError,
+  VettlyError: () => VettlyError,
+  VettlyRateLimitError: () => VettlyRateLimitError,
+  VettlyValidationError: () => VettlyValidationError,
+  createClient: () => createClient,
+  createModerationHandler: () => createModerationHandler,
+  moderate: () => moderate,
+  moderateImage: () => moderateImage,
+  withModeration: () => withModeration
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var VettlyError = class extends Error {
+  code;
+  statusCode;
+  responseBody;
+  constructor(message, code, statusCode, responseBody) {
+    super(message);
+    this.name = "VettlyError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+  }
+};
+var VettlyAuthError = class extends VettlyError {
+  constructor(message = "Invalid API key") {
+    super(message, "AUTH_ERROR", 401);
+    this.name = "VettlyAuthError";
+  }
+};
+var VettlyRateLimitError = class extends VettlyError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, "RATE_LIMIT", 429);
+    this.name = "VettlyRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var VettlyValidationError = class extends VettlyError {
+  errors;
+  constructor(message, errors) {
+    super(message, "VALIDATION_ERROR", 422);
+    this.name = "VettlyValidationError";
+    this.errors = errors;
+  }
+};
+
+// src/client.ts
+var DEFAULT_API_URL = "https://api.vettly.dev";
+var DEFAULT_TIMEOUT = 3e4;
+var SDK_VERSION = "0.1.0";
+function createClient(config) {
+  const apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+  const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+  const apiKey = config.apiKey;
+  if (!apiKey) {
+    throw new VettlyError(
+      "API key is required",
+      "CONFIG_ERROR",
+      500
+    );
+  }
+  async function request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(`${apiUrl}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "User-Agent": `@vettly/supabase/${SDK_VERSION}`,
+          "X-Vettly-SDK-Version": SDK_VERSION
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        switch (response.status) {
+          case 401:
+            throw new VettlyAuthError(errorBody.error || "Invalid API key");
+          case 429: {
+            const retryAfter = response.headers.get("Retry-After");
+            throw new VettlyRateLimitError(
+              errorBody.error || "Rate limit exceeded",
+              retryAfter ? parseInt(retryAfter, 10) : void 0
+            );
+          }
+          case 422:
+            throw new VettlyValidationError(
+              errorBody.error || "Validation error",
+              Array.isArray(errorBody.details) ? errorBody.details : []
+            );
+          default:
+            throw new VettlyError(
+              errorBody.error || `Request failed with status ${response.status}`,
+              errorBody.code || "API_ERROR",
+              response.status,
+              errorBody
+            );
+        }
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof VettlyError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new VettlyError(
+          `Request timed out after ${timeout}ms`,
+          "TIMEOUT",
+          408
+        );
+      }
+      throw new VettlyError(
+        error instanceof Error ? error.message : "Unknown error",
+        "NETWORK_ERROR",
+        500
+      );
+    }
+  }
+  return {
+    /**
+     * Moderate text content
+     */
+    async check(content, options = {}) {
+      return request("POST", "/v1/moderate", {
+        content,
+        policyId: options.policyId ?? "default",
+        contentType: options.contentType ?? "text",
+        language: options.language,
+        metadata: options.metadata,
+        requestId: options.requestId
+      });
+    },
+    /**
+     * Moderate an image
+     */
+    async checkImage(imageUrl, options = {}) {
+      return request("POST", "/v1/moderate", {
+        content: imageUrl,
+        policyId: options.policyId ?? "default",
+        contentType: "image",
+        metadata: options.metadata,
+        requestId: options.requestId
+      });
+    }
+  };
+}
+var defaultClient = null;
+function getDefaultClient() {
+  if (defaultClient) {
+    return defaultClient;
+  }
+  const apiKey = typeof Deno !== "undefined" ? Deno.env.get("VETTLY_API_KEY") : typeof process !== "undefined" ? process.env.VETTLY_API_KEY : void 0;
+  if (!apiKey) {
+    throw new VettlyError(
+      "VETTLY_API_KEY environment variable is not set",
+      "CONFIG_ERROR",
+      500
+    );
+  }
+  defaultClient = createClient({ apiKey });
+  return defaultClient;
+}
+async function moderate(content, options = {}) {
+  return getDefaultClient().check(content, options);
+}
+async function moderateImage(imageUrl, options = {}) {
+  return getDefaultClient().checkImage(imageUrl, options);
+}
+
+// src/edge.ts
+async function defaultGetContent(req) {
+  try {
+    const body = await req.json();
+    return typeof body.content === "string" ? body.content : null;
+  } catch {
+    return null;
+  }
+}
+function createModerationHandler(config = {}) {
+  const {
+    apiKey,
+    policyId = "default",
+    getContent = defaultGetContent,
+    onBlock,
+    onFlag,
+    onWarn,
+    onAllow,
+    onError
+  } = config;
+  const resolvedApiKey = apiKey ?? (typeof Deno !== "undefined" ? Deno.env.get("VETTLY_API_KEY") : typeof process !== "undefined" ? process.env.VETTLY_API_KEY : void 0);
+  if (!resolvedApiKey) {
+    throw new VettlyError(
+      "API key is required. Set VETTLY_API_KEY env var or pass apiKey in config.",
+      "CONFIG_ERROR",
+      500
+    );
+  }
+  const client = createClient({ apiKey: resolvedApiKey });
+  return async (req) => {
+    if (req.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+        }
+      });
+    }
+    if (req.method !== "POST") {
+      return new Response(
+        JSON.stringify({ error: "Method not allowed" }),
+        {
+          status: 405,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    try {
+      const content = await getContent(req);
+      if (!content) {
+        return new Response(
+          JSON.stringify({ error: "No content to moderate" }),
+          {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      const result = await client.check(content, { policyId });
+      if (result.action === "block") {
+        if (onBlock) {
+          return onBlock(result, req);
+        }
+        return new Response(
+          JSON.stringify({
+            error: "Content blocked",
+            categories: result.categories.filter((c) => c.flagged)
+          }),
+          {
+            status: 403,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      if (result.action === "flag" && onFlag) {
+        await onFlag(result, req);
+      }
+      if (result.action === "warn" && onWarn) {
+        await onWarn(result, req);
+      }
+      if (onAllow) {
+        return onAllow(result, req);
+      }
+      return new Response(
+        JSON.stringify({
+          success: true,
+          moderation: {
+            safe: result.safe,
+            action: result.action,
+            decisionId: result.decisionId
+          }
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    } catch (error) {
+      if (onError) {
+        return onError(error instanceof Error ? error : new Error(String(error)), req);
+      }
+      console.error("[Vettly] Moderation error:", error);
+      return new Response(
+        JSON.stringify({
+          error: "Moderation service error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+function withModeration(handler, config = {}) {
+  const {
+    apiKey,
+    policyId = "default",
+    getContent = defaultGetContent,
+    onBlock,
+    onError
+  } = config;
+  const resolvedApiKey = apiKey ?? (typeof Deno !== "undefined" ? Deno.env.get("VETTLY_API_KEY") : typeof process !== "undefined" ? process.env.VETTLY_API_KEY : void 0);
+  if (!resolvedApiKey) {
+    throw new VettlyError(
+      "API key is required. Set VETTLY_API_KEY env var or pass apiKey in config.",
+      "CONFIG_ERROR",
+      500
+    );
+  }
+  const client = createClient({ apiKey: resolvedApiKey });
+  return async (req) => {
+    if (req.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+        }
+      });
+    }
+    try {
+      const clonedReq = req.clone();
+      const content = await getContent(clonedReq);
+      if (!content) {
+        return new Response(
+          JSON.stringify({ error: "No content to moderate" }),
+          {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      const result = await client.check(content, { policyId });
+      if (result.action === "block") {
+        if (onBlock) {
+          return onBlock(result, req);
+        }
+        return new Response(
+          JSON.stringify({
+            error: "Content blocked",
+            categories: result.categories.filter((c) => c.flagged)
+          }),
+          {
+            status: 403,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      return handler(req, result);
+    } catch (error) {
+      if (onError) {
+        return onError(error instanceof Error ? error : new Error(String(error)), req);
+      }
+      console.error("[Vettly] Moderation error:", error);
+      return new Response(
+        JSON.stringify({
+          error: "Moderation service error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VettlyAuthError,
+  VettlyError,
+  VettlyRateLimitError,
+  VettlyValidationError,
+  createClient,
+  createModerationHandler,
+  moderate,
+  moderateImage,
+  withModeration
+});

package/dist/index.d.cts

@@ -0,0 +1,31 @@
+import { V as VettlyConfig, M as ModerationOptions, a as ModerationResult } from './edge-CPse0nUh.cjs';
+export { A as Action, b as Category, d as CategoryScore, C as ContentType, E as EdgeHandlerOptions, e as ModerationHandlerConfig, g as VettlyAuthError, f as VettlyError, h as VettlyRateLimitError, i as VettlyValidationError, c as createModerationHandler, w as withModeration } from './edge-CPse0nUh.cjs';
+
+/**
+ * Vettly Client for Supabase Edge Functions
+ * Fetch-based, Deno-compatible client
+ */
+
+/**
+ * Create a configured Vettly client
+ */
+declare function createClient(config: VettlyConfig): {
+    /**
+     * Moderate text content
+     */
+    check(content: string, options?: ModerationOptions): Promise<ModerationResult>;
+    /**
+     * Moderate an image
+     */
+    checkImage(imageUrl: string, options?: ModerationOptions): Promise<ModerationResult>;
+};
+/**
+ * Moderate text content using the default client
+ */
+declare function moderate(content: string, options?: ModerationOptions): Promise<ModerationResult>;
+/**
+ * Moderate an image using the default client
+ */
+declare function moderateImage(imageUrl: string, options?: ModerationOptions): Promise<ModerationResult>;
+
+export { ModerationOptions, ModerationResult, VettlyConfig, createClient, moderate, moderateImage };

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { V as VettlyConfig, M as ModerationOptions, a as ModerationResult } from './edge-CPse0nUh.js';
+export { A as Action, b as Category, d as CategoryScore, C as ContentType, E as EdgeHandlerOptions, e as ModerationHandlerConfig, g as VettlyAuthError, f as VettlyError, h as VettlyRateLimitError, i as VettlyValidationError, c as createModerationHandler, w as withModeration } from './edge-CPse0nUh.js';
+
+/**
+ * Vettly Client for Supabase Edge Functions
+ * Fetch-based, Deno-compatible client
+ */
+
+/**
+ * Create a configured Vettly client
+ */
+declare function createClient(config: VettlyConfig): {
+    /**
+     * Moderate text content
+     */
+    check(content: string, options?: ModerationOptions): Promise<ModerationResult>;
+    /**
+     * Moderate an image
+     */
+    checkImage(imageUrl: string, options?: ModerationOptions): Promise<ModerationResult>;
+};
+/**
+ * Moderate text content using the default client
+ */
+declare function moderate(content: string, options?: ModerationOptions): Promise<ModerationResult>;
+/**
+ * Moderate an image using the default client
+ */
+declare function moderateImage(imageUrl: string, options?: ModerationOptions): Promise<ModerationResult>;
+
+export { ModerationOptions, ModerationResult, VettlyConfig, createClient, moderate, moderateImage };

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  VettlyAuthError,
+  VettlyError,
+  VettlyRateLimitError,
+  VettlyValidationError,
+  createClient,
+  createModerationHandler,
+  moderate,
+  moderateImage,
+  withModeration
+} from "./chunk-LTC3D75K.js";
+export {
+  VettlyAuthError,
+  VettlyError,
+  VettlyRateLimitError,
+  VettlyValidationError,
+  createClient,
+  createModerationHandler,
+  moderate,
+  moderateImage,
+  withModeration
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@vettly/supabase",
+  "version": "0.1.0",
+  "description": "Vettly content moderation for Supabase Edge Functions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./edge": {
+      "types": "./dist/edge.d.ts",
+      "import": "./dist/edge.js",
+      "require": "./dist/edge.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/edge.ts --format esm,cjs --dts --clean",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "supabase",
+    "edge-functions",
+    "deno",
+    "content-moderation",
+    "moderation",
+    "vettly",
+    "trust-safety"
+  ],
+  "author": "Vettly",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brian-nextaura/vettly-docs.git",
+    "directory": "packages/supabase"
+  },
+  "homepage": "https://vettly.dev",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/brian-nextaura/vettly-docs/issues"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsup": "^8.0.0",
+    "typescript": "^5"
+  }
+}