@vettly/supabase 0.1.0

package/dist/edge-CPse0nUh.d.cts

@@ -0,0 +1,137 @@
+/**
+ * Vettly Supabase Types
+ * Self-contained types for Deno Edge Function compatibility
+ */
+type ContentType = 'text' | 'image' | 'video';
+type Action = 'block' | 'warn' | 'flag' | 'allow';
+type Category = 'hate_speech' | 'harassment' | 'violence' | 'self_harm' | 'sexual' | 'spam' | 'profanity' | 'scam' | 'illegal';
+interface CategoryScore {
+    category: Category;
+    score: number;
+    flagged: boolean;
+}
+interface ModerationResult {
+    decisionId: string;
+    safe: boolean;
+    flagged: boolean;
+    action: Action;
+    categories: CategoryScore[];
+    provider: string;
+    latency: number;
+    cost: number;
+}
+interface ModerationOptions {
+    /** Policy ID to use for moderation (defaults to 'default') */
+    policyId?: string;
+    /** Content type hint */
+    contentType?: ContentType;
+    /** Language hint (ISO 639-1) */
+    language?: string;
+    /** Request metadata */
+    metadata?: Record<string, unknown>;
+    /** Idempotency key */
+    requestId?: string;
+}
+interface VettlyConfig {
+    /** Your Vettly API key */
+    apiKey: string;
+    /** API base URL (defaults to https://api.vettly.dev) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (defaults to 30000) */
+    timeout?: number;
+}
+declare class VettlyError extends Error {
+    code: string;
+    statusCode: number;
+    responseBody?: unknown;
+    constructor(message: string, code: string, statusCode: number, responseBody?: unknown);
+}
+declare class VettlyAuthError extends VettlyError {
+    constructor(message?: string);
+}
+declare class VettlyRateLimitError extends VettlyError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class VettlyValidationError extends VettlyError {
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message: string, errors: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+interface EdgeHandlerOptions {
+    /** Policy ID to use for moderation */
+    policyId?: string;
+    /** Function to extract content from request (default: reads JSON body.content) */
+    getContent?: (req: Request) => Promise<string | null>;
+    /** Called when content is blocked */
+    onBlock?: (result: ModerationResult, req: Request) => Response | Promise<Response>;
+    /** Called when content is flagged (but allowed) */
+    onFlag?: (result: ModerationResult, req: Request) => void | Promise<void>;
+    /** Called when content is warned (but allowed) */
+    onWarn?: (result: ModerationResult, req: Request) => void | Promise<void>;
+    /** Called when moderation passes */
+    onAllow?: (result: ModerationResult, req: Request) => Response | Promise<Response>;
+    /** Called on error (default: returns 500) */
+    onError?: (error: Error, req: Request) => Response | Promise<Response>;
+}
+interface ModerationHandlerConfig extends EdgeHandlerOptions {
+    /** Your Vettly API key (or set VETTLY_API_KEY env var) */
+    apiKey?: string;
+}
+
+/**
+ * Vettly Edge Function Helpers
+ * Deno-compatible handlers for Supabase Edge Functions
+ */
+
+/**
+ * Create an Edge Function handler that moderates incoming requests
+ *
+ * @example
+ * ```typescript
+ * // Simple one-liner
+ * Deno.serve(createModerationHandler({
+ *   policyId: 'strict',
+ *   onBlock: () => new Response('Content blocked', { status: 403 })
+ * }))
+ *
+ * // With custom content extraction
+ * Deno.serve(createModerationHandler({
+ *   getContent: async (req) => {
+ *     const { message } = await req.json()
+ *     return message
+ *   },
+ *   onBlock: (result) => Response.json({
+ *     error: 'blocked',
+ *     categories: result.categories.filter(c => c.flagged)
+ *   }, { status: 403 })
+ * }))
+ * ```
+ */
+declare function createModerationHandler(config?: ModerationHandlerConfig): (req: Request) => Promise<Response>;
+/**
+ * Create a middleware-style handler that moderates content before passing to your handler
+ *
+ * @example
+ * ```typescript
+ * const handler = withModeration(
+ *   async (req, moderationResult) => {
+ *     // Content is already moderated, safe to process
+ *     const { content, userId } = await req.json()
+ *     // Insert into database...
+ *     return Response.json({ success: true })
+ *   },
+ *   { policyId: 'user-content' }
+ * )
+ *
+ * Deno.serve(handler)
+ * ```
+ */
+declare function withModeration(handler: (req: Request, result: ModerationResult) => Promise<Response>, config?: ModerationHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type Action as A, type ContentType as C, type EdgeHandlerOptions as E, type ModerationOptions as M, type VettlyConfig as V, type ModerationResult as a, type Category as b, createModerationHandler as c, type CategoryScore as d, type ModerationHandlerConfig as e, VettlyError as f, VettlyAuthError as g, VettlyRateLimitError as h, VettlyValidationError as i, withModeration as w };

package/dist/edge-CPse0nUh.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Vettly Supabase Types
+ * Self-contained types for Deno Edge Function compatibility
+ */
+type ContentType = 'text' | 'image' | 'video';
+type Action = 'block' | 'warn' | 'flag' | 'allow';
+type Category = 'hate_speech' | 'harassment' | 'violence' | 'self_harm' | 'sexual' | 'spam' | 'profanity' | 'scam' | 'illegal';
+interface CategoryScore {
+    category: Category;
+    score: number;
+    flagged: boolean;
+}
+interface ModerationResult {
+    decisionId: string;
+    safe: boolean;
+    flagged: boolean;
+    action: Action;
+    categories: CategoryScore[];
+    provider: string;
+    latency: number;
+    cost: number;
+}
+interface ModerationOptions {
+    /** Policy ID to use for moderation (defaults to 'default') */
+    policyId?: string;
+    /** Content type hint */
+    contentType?: ContentType;
+    /** Language hint (ISO 639-1) */
+    language?: string;
+    /** Request metadata */
+    metadata?: Record<string, unknown>;
+    /** Idempotency key */
+    requestId?: string;
+}
+interface VettlyConfig {
+    /** Your Vettly API key */
+    apiKey: string;
+    /** API base URL (defaults to https://api.vettly.dev) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (defaults to 30000) */
+    timeout?: number;
+}
+declare class VettlyError extends Error {
+    code: string;
+    statusCode: number;
+    responseBody?: unknown;
+    constructor(message: string, code: string, statusCode: number, responseBody?: unknown);
+}
+declare class VettlyAuthError extends VettlyError {
+    constructor(message?: string);
+}
+declare class VettlyRateLimitError extends VettlyError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class VettlyValidationError extends VettlyError {
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message: string, errors: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+interface EdgeHandlerOptions {
+    /** Policy ID to use for moderation */
+    policyId?: string;
+    /** Function to extract content from request (default: reads JSON body.content) */
+    getContent?: (req: Request) => Promise<string | null>;
+    /** Called when content is blocked */
+    onBlock?: (result: ModerationResult, req: Request) => Response | Promise<Response>;
+    /** Called when content is flagged (but allowed) */
+    onFlag?: (result: ModerationResult, req: Request) => void | Promise<void>;
+    /** Called when content is warned (but allowed) */
+    onWarn?: (result: ModerationResult, req: Request) => void | Promise<void>;
+    /** Called when moderation passes */
+    onAllow?: (result: ModerationResult, req: Request) => Response | Promise<Response>;
+    /** Called on error (default: returns 500) */
+    onError?: (error: Error, req: Request) => Response | Promise<Response>;
+}
+interface ModerationHandlerConfig extends EdgeHandlerOptions {
+    /** Your Vettly API key (or set VETTLY_API_KEY env var) */
+    apiKey?: string;
+}
+
+/**
+ * Vettly Edge Function Helpers
+ * Deno-compatible handlers for Supabase Edge Functions
+ */
+
+/**
+ * Create an Edge Function handler that moderates incoming requests
+ *
+ * @example
+ * ```typescript
+ * // Simple one-liner
+ * Deno.serve(createModerationHandler({
+ *   policyId: 'strict',
+ *   onBlock: () => new Response('Content blocked', { status: 403 })
+ * }))
+ *
+ * // With custom content extraction
+ * Deno.serve(createModerationHandler({
+ *   getContent: async (req) => {
+ *     const { message } = await req.json()
+ *     return message
+ *   },
+ *   onBlock: (result) => Response.json({
+ *     error: 'blocked',
+ *     categories: result.categories.filter(c => c.flagged)
+ *   }, { status: 403 })
+ * }))
+ * ```
+ */
+declare function createModerationHandler(config?: ModerationHandlerConfig): (req: Request) => Promise<Response>;
+/**
+ * Create a middleware-style handler that moderates content before passing to your handler
+ *
+ * @example
+ * ```typescript
+ * const handler = withModeration(
+ *   async (req, moderationResult) => {
+ *     // Content is already moderated, safe to process
+ *     const { content, userId } = await req.json()
+ *     // Insert into database...
+ *     return Response.json({ success: true })
+ *   },
+ *   { policyId: 'user-content' }
+ * )
+ *
+ * Deno.serve(handler)
+ * ```
+ */
+declare function withModeration(handler: (req: Request, result: ModerationResult) => Promise<Response>, config?: ModerationHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type Action as A, type ContentType as C, type EdgeHandlerOptions as E, type ModerationOptions as M, type VettlyConfig as V, type ModerationResult as a, type Category as b, createModerationHandler as c, type CategoryScore as d, type ModerationHandlerConfig as e, VettlyError as f, VettlyAuthError as g, VettlyRateLimitError as h, VettlyValidationError as i, withModeration as w };

package/dist/edge.cjs

@@ -0,0 +1,366 @@
+"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/edge.ts
+var edge_exports = {};
+__export(edge_exports, {
+  createModerationHandler: () => createModerationHandler,
+  withModeration: () => withModeration
+});
+module.exports = __toCommonJS(edge_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
+      });
+    }
+  };
+}
+
+// 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 = {
+  createModerationHandler,
+  withModeration
+});

package/dist/edge.d.cts

@@ -0,0 +1 @@
+export { E as EdgeHandlerOptions, e as ModerationHandlerConfig, a as ModerationResult, c as createModerationHandler, w as withModeration } from './edge-CPse0nUh.cjs';

package/dist/edge.d.ts

@@ -0,0 +1 @@
+export { E as EdgeHandlerOptions, e as ModerationHandlerConfig, a as ModerationResult, c as createModerationHandler, w as withModeration } from './edge-CPse0nUh.js';

package/dist/edge.js

@@ -0,0 +1,8 @@
+import {
+  createModerationHandler,
+  withModeration
+} from "./chunk-LTC3D75K.js";
+export {
+  createModerationHandler,
+  withModeration
+};