@vettly/supabase 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # @vettly/supabase
 
-Vettly content moderation for Supabase Edge Functions. Deno-compatible, fetch-based client.
+Vettly decision infrastructure for Supabase Edge Functions. Deno-compatible client with fetch-based transport for serverless environments.
 
 ## Installation
 
@@ -8,7 +8,7 @@ Vettly content moderation for Supabase Edge Functions. Deno-compatible, fetch-ba
 npm install @vettly/supabase
 ```
 
-Or with Deno in your Edge Function:
+Or import directly in Deno:
 
 ```typescript
 import { moderate } from 'npm:@vettly/supabase'
@@ -21,246 +21,128 @@ import { moderate } from 'npm:@vettly/supabase'
 ```typescript
 import { createModerationHandler } from '@vettly/supabase'
 
-// Moderate all incoming content
 Deno.serve(createModerationHandler({
   policyId: 'default',
   onBlock: (result) => new Response(JSON.stringify({
     error: 'Content blocked',
-    reason: result.categories.filter(c => c.flagged)
-  }), { status: 403, headers: { 'Content-Type': 'application/json' } })
+    categories: result.categories
+  }), { status: 403 })
 }))
 ```
 
-### Manual Control
+### Manual Integration
 
 ```typescript
-import { moderate } from '@vettly/supabase'
+import { createClient } from '@vettly/supabase'
+
+const vettly = createClient({
+  apiKey: Deno.env.get('VETTLY_API_KEY')!
+})
 
 Deno.serve(async (req) => {
-  const { content, userId } = await req.json()
+  const { content } = await req.json()
 
-  // Moderate content first
-  const result = await moderate(content, { policyId: 'strict' })
+  const result = await vettly.check(content, {
+    policyId: 'community-safe'
+  })
 
   if (result.action === 'block') {
     return new Response('Content blocked', { status: 403 })
   }
 
-  // Content is safe, continue with your logic
-  // await supabase.from('posts').insert({ content, userId })
-
-  return new Response(JSON.stringify({ success: true }), {
-    headers: { 'Content-Type': 'application/json' }
-  })
+  return new Response('OK')
 })
 ```
 
-### Middleware Pattern
-
-```typescript
-import { withModeration } from '@vettly/supabase'
-
-const handler = withModeration(
-  async (req, moderationResult) => {
-    // Content already passed moderation
-    const { content, userId } = await req.json()
-
-    // Insert into database...
-    // await supabase.from('posts').insert({ content, userId })
-
-    return new Response(JSON.stringify({
-      success: true,
-      moderation: {
-        decisionId: moderationResult.decisionId,
-        safe: moderationResult.safe
-      }
-    }), { headers: { 'Content-Type': 'application/json' } })
-  },
-  { policyId: 'user-content' }
-)
-
-Deno.serve(handler)
-```
-
-## Configuration
-
-### Environment Variable
-
-Set `VETTLY_API_KEY` in your Supabase project secrets:
+## API
 
-```bash
-supabase secrets set VETTLY_API_KEY=your_api_key
-```
+### `createClient(config)`
 
-### Programmatic Configuration
+Create a configured Vettly client.
 
 ```typescript
-import { createClient } from '@vettly/supabase'
-
-const vettly = createClient({
-  apiKey: Deno.env.get('VETTLY_API_KEY')!,
-  apiUrl: 'https://api.vettly.dev', // optional
-  timeout: 30000 // optional, in ms
+const client = createClient({
+  apiKey: 'sk_live_...',
+  apiUrl: 'https://api.vettly.dev' // optional
 })
 
-const result = await vettly.check('Hello world', { policyId: 'default' })
-```
-
-## API Reference
-
-### `moderate(content, options?)`
-
-Moderate text content using the default client.
-
-```typescript
-const result = await moderate('User generated content', {
-  policyId: 'strict',      // Policy to use (default: 'default')
-  contentType: 'text',     // 'text' | 'image' | 'video'
-  language: 'en',          // ISO 639-1 language code
-  metadata: { userId: '123' }
-})
+// Check text
+const result = await client.check('user content', { policyId: 'default' })
 
-// Result:
-// {
-//   decisionId: 'dec_123',
-//   safe: true,
-//   flagged: false,
-//   action: 'allow',
-//   categories: [{ category: 'hate_speech', score: 0.01, flagged: false }],
-//   provider: 'openai',
-//   latency: 150,
-//   cost: 0.0001
-// }
+// Check image
+const result = await client.checkImage('https://...', { policyId: 'strict' })
 ```
 
-### `moderateImage(imageUrl, options?)`
+### `moderate(content, options)`
 
-Moderate an image by URL.
+Quick moderation without creating a client (uses `VETTLY_API_KEY` env var).
 
 ```typescript
-const result = await moderateImage('https://example.com/image.jpg', {
-  policyId: 'images'
-})
+import { moderate } from '@vettly/supabase'
+
+const result = await moderate('user content', { policyId: 'default' })
 ```
 
 ### `createModerationHandler(config)`
 
-Create an Edge Function handler that moderates incoming requests.
+Create an Edge Function handler that automatically moderates incoming requests.
 
 ```typescript
-import { createModerationHandler } from '@vettly/supabase'
-
-Deno.serve(createModerationHandler({
-  apiKey: Deno.env.get('VETTLY_API_KEY'),  // Optional, uses env var by default
-  policyId: 'default',
-
-  // Custom content extraction (default: reads req.json().content)
-  getContent: async (req) => {
-    const { message } = await req.json()
-    return message
-  },
-
-  // Handle blocked content
-  onBlock: (result, req) => {
-    return new Response(JSON.stringify({ blocked: true }), { status: 403 })
-  },
-
-  // Handle flagged content (logged but allowed)
-  onFlag: (result, req) => {
-    console.log('Flagged content:', result.decisionId)
-  },
-
-  // Handle warnings
-  onWarn: (result, req) => {
-    console.log('Warning:', result.categories)
-  },
-
-  // Handle allowed content
-  onAllow: (result, req) => {
-    return new Response(JSON.stringify({ success: true }))
-  },
-
-  // Handle errors
-  onError: (error, req) => {
-    console.error('Moderation error:', error)
-    return new Response('Error', { status: 500 })
+import { createModerationHandler } from '@vettly/supabase/edge'
+
+export default createModerationHandler({
+  policyId: 'community-safe',
+  field: 'content', // JSON field to moderate
+  onBlock: (result) => new Response('Blocked', { status: 403 }),
+  onAllow: (req, result) => {
+    // Continue processing
   }
-}))
+})
 ```
 
 ### `withModeration(handler, config)`
 
-Middleware-style handler that moderates content before passing to your handler.
+Wrap an existing Edge Function with moderation.
 
 ```typescript
-import { withModeration } from '@vettly/supabase'
+import { withModeration } from '@vettly/supabase/edge'
 
-const handler = withModeration(
-  async (req, moderationResult) => {
-    // Your handler receives the moderation result
-    console.log('Decision ID:', moderationResult.decisionId)
-    console.log('Safe:', moderationResult.safe)
-
-    // Process the request...
-    return new Response(JSON.stringify({ success: true }))
-  },
-  { policyId: 'user-content' }
-)
-
-Deno.serve(handler)
-```
-
-### `createClient(config)`
-
-Create a configured Vettly client for more control.
+const handler = async (req: Request) => {
+  // Your logic here
+  return new Response('OK')
+}
 
-```typescript
-const client = createClient({
-  apiKey: 'vettly_...',
-  apiUrl: 'https://api.vettly.dev',
-  timeout: 30000
+export default withModeration(handler, {
+  policyId: 'default',
+  field: 'body'
 })
-
-// Text moderation
-const textResult = await client.check('Hello world', { policyId: 'default' })
-
-// Image moderation
-const imageResult = await client.checkImage('https://...', { policyId: 'images' })
 ```
 
-## Error Handling
+## Response Format
 
 ```typescript
-import { moderate, VettlyError, VettlyAuthError, VettlyRateLimitError } from '@vettly/supabase'
-
-try {
-  const result = await moderate('content')
-} catch (error) {
-  if (error instanceof VettlyAuthError) {
-    console.error('Invalid API key')
-  } else if (error instanceof VettlyRateLimitError) {
-    console.error('Rate limited, retry after:', error.retryAfter)
-  } else if (error instanceof VettlyError) {
-    console.error('Vettly error:', error.code, error.message)
-  }
+interface ModerationResult {
+  decisionId: string
+  safe: boolean
+  flagged: boolean
+  action: 'allow' | 'warn' | 'flag' | 'block'
+  categories: Array<{
+    category: string
+    score: number
+    triggered: boolean
+  }>
+  latency: number
 }
 ```
 
-## TypeScript Types
+## Environment Variables
 
-```typescript
-import type {
-  ModerationResult,
-  ModerationOptions,
-  Action,
-  Category,
-  CategoryScore,
-  VettlyConfig,
-  EdgeHandlerOptions,
-  ModerationHandlerConfig
-} from '@vettly/supabase'
-```
+Set in your Supabase project settings:
+
+- `VETTLY_API_KEY` - Your Vettly API key (required)
 
-## License
+## Links
 
-MIT
+- [vettly.dev](https://vettly.dev) - Sign up
+- [docs.vettly.dev](https://docs.vettly.dev) - Documentation
+- [Supabase Edge Functions](https://supabase.com/docs/guides/functions) - Supabase docs

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@vettly/supabase",
-  "version": "0.1.0",
-  "description": "Vettly content moderation for Supabase Edge Functions",
+  "version": "0.1.1",
+  "description": "Vettly decision infrastructure for Supabase Edge Functions. Deno-compatible, fetch-based client.",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
@@ -21,25 +22,19 @@
     "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": [
+    "vettly",
     "supabase",
     "edge-functions",
     "deno",
-    "content-moderation",
-    "moderation",
-    "vettly",
-    "trust-safety"
+    "decision-infrastructure",
+    "policy-governance"
   ],
   "author": "Vettly",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/brian-nextaura/vettly-docs.git",
+    "url": "https://github.com/nextauralabs/vettly-docs.git",
     "directory": "packages/supabase"
   },
   "homepage": "https://vettly.dev",
@@ -47,11 +42,6 @@
     "access": "public"
   },
   "bugs": {
-    "url": "https://github.com/brian-nextaura/vettly-docs/issues"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "tsup": "^8.0.0",
-    "typescript": "^5"
+    "url": "https://github.com/nextauralabs/vettly-docs/issues"
   }
 }