@jonsoc/convex 1.1.46 → 1.1.51

package/convex/http.ts

@@ -1,9 +1,213 @@
 import { httpRouter } from "convex/server"
+import type { HttpRouter } from "convex/server"
 
 import { authComponent, createAuth } from "./auth"
 
-const http = httpRouter()
+const http: HttpRouter = httpRouter()
 
 authComponent.registerRoutes(http, createAuth, { cors: true })
 
+// Share API endpoints - POST /api/share
+http.route({
+  path: "/api/share",
+  method: "POST",
+  handler: async (ctx, request) => {
+    try {
+      const body = await request.json()
+
+      // Import the share module dynamically
+      const { create } = await import("./share")
+
+      const result = await ctx.runMutation(create, {
+        sessionID: body.sessionID,
+        slug: body.sessionID, // Use sessionID as slug
+        secret: generateSecret(),
+      })
+
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    } catch (error) {
+      return new Response(JSON.stringify({ error: String(error) }), {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    }
+  },
+})
+
+// Share sync endpoint - POST /api/share/:slug/sync
+http.route({
+  path: "/api/share/:slug/sync",
+  method: "POST",
+  handler: async (ctx, request) => {
+    try {
+      const slug = request.params.slug
+      const body = await request.json()
+
+      const { sync } = await import("./share")
+
+      await ctx.runMutation(sync, {
+        slug,
+        secret: body.secret,
+        data: body.data,
+      })
+
+      return new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    } catch (error) {
+      return new Response(JSON.stringify({ error: String(error) }), {
+        status: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    }
+  },
+})
+
+// Share delete endpoint - DELETE /api/share/:slug
+http.route({
+  path: "/api/share/:slug",
+  method: "DELETE",
+  handler: async (ctx, request) => {
+    try {
+      const slug = request.params.slug
+      const body = await request.json()
+
+      const { remove } = await import("./share")
+
+      await ctx.runMutation(remove, {
+        slug,
+        secret: body.secret,
+      })
+
+      return new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    } catch (error) {
+      return new Response(JSON.stringify({ error: String(error) }), {
+        status: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    }
+  },
+})
+
+// Share get endpoint - GET /api/share/:slug
+http.route({
+  path: "/api/share/:slug",
+  method: "GET",
+  handler: async (ctx, request) => {
+    try {
+      const slug = request.params.slug
+
+      const { getPublic } = await import("./share")
+
+      const result = await ctx.runQuery(getPublic, { slug })
+
+      if (!result) {
+        return new Response(JSON.stringify({ error: "Share not found" }), {
+          status: 404,
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        })
+      }
+
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    } catch (error) {
+      return new Response(JSON.stringify({ error: String(error) }), {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      })
+    }
+  },
+})
+
+// CORS preflight for share endpoints
+http.route({
+  path: "/api/share",
+  method: "OPTIONS",
+  handler: async () => {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+      },
+    })
+  },
+})
+
+http.route({
+  path: "/api/share/:slug",
+  method: "OPTIONS",
+  handler: async () => {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+      },
+    })
+  },
+})
+
+http.route({
+  path: "/api/share/:slug/sync",
+  method: "OPTIONS",
+  handler: async () => {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+      },
+    })
+  },
+})
+
+function generateSecret(): string {
+  // Generate a random UUID-like string
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0
+    const v = c === "x" ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}
+
 export default http

package/convex/schema.ts

@@ -1,4 +1,40 @@
 import { defineSchema, defineTable } from "convex/server"
 import { v } from "convex/values"
 
-export default defineSchema({})
+export default defineSchema({
+  shares: defineTable({
+    // Unique share ID (ULID from CLI)
+    slug: v.string(),
+    // Secret for authentication (only share creator knows this)
+    secret: v.string(),
+    // Session metadata
+    sessionID: v.string(),
+    title: v.optional(v.string()),
+    model: v.optional(v.string()),
+    // Visibility
+    isPublic: v.boolean(),
+    // Timestamps
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    // Soft delete
+    isDeleted: v.boolean(),
+  })
+    .index("by_slug", ["slug"])
+    .index("by_secret", ["secret"])
+    .index("by_session", ["sessionID"]),
+
+  // Share data stored as JSON blobs (messages, diffs, etc)
+  shareData: defineTable({
+    shareID: v.id("shares"),
+    // Type: "session" | "message" | "part" | "session_diff" | "model"
+    dataType: v.string(),
+    // Data ID (message ID, part ID, etc)
+    dataID: v.string(),
+    // JSON string of the actual data
+    payload: v.string(),
+    createdAt: v.number(),
+  })
+    .index("by_share", ["shareID"])
+    .index("by_share_data", ["shareID", "dataType"])
+    .index("by_data_id", ["dataID"]),
+})

package/convex/share.ts

@@ -0,0 +1,220 @@
+import { v } from "convex/values"
+import { mutation, query } from "./_generated/server"
+
+export const create = mutation({
+  args: {
+    sessionID: v.string(),
+    slug: v.string(),
+    secret: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now()
+
+    // Check if share already exists for this session
+    const existing = await ctx.db
+      .query("shares")
+      .withIndex("by_session", (q) => q.eq("sessionID", args.sessionID))
+      .first()
+
+    if (existing) {
+      // Return existing share
+      return {
+        id: existing.slug,
+        url: `/share/${existing.slug}`,
+        secret: existing.secret,
+      }
+    }
+
+    // Create new share
+    const share = await ctx.db.insert("shares", {
+      slug: args.slug,
+      secret: args.secret,
+      sessionID: args.sessionID,
+      title: undefined,
+      model: undefined,
+      isPublic: true,
+      createdAt: now,
+      updatedAt: now,
+      isDeleted: false,
+    })
+
+    return {
+      id: args.slug,
+      url: `/share/${args.slug}`,
+      secret: args.secret,
+    }
+  },
+})
+
+export const sync = mutation({
+  args: {
+    slug: v.string(),
+    secret: v.string(),
+    data: v.array(
+      v.object({
+        type: v.string(),
+        data: v.any(),
+      }),
+    ),
+  },
+  handler: async (ctx, args) => {
+    // Verify share exists and secret matches
+    const share = await ctx.db
+      .query("shares")
+      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
+      .first()
+
+    if (!share || share.secret !== args.secret) {
+      throw new Error("Share not found or invalid secret")
+    }
+
+    if (share.isDeleted) {
+      throw new Error("Share has been deleted")
+    }
+
+    // Process each data item
+    for (const item of args.data) {
+      const dataID = item.data?.id || crypto.randomUUID()
+      const payload = JSON.stringify(item.data)
+
+      // Check if data already exists
+      const existing = await ctx.db
+        .query("shareData")
+        .withIndex("by_data_id", (q) => q.eq("dataID", dataID))
+        .first()
+
+      if (existing) {
+        // Update existing
+        await ctx.db.patch(existing._id, {
+          payload,
+          createdAt: Date.now(),
+        })
+      } else {
+        // Create new
+        await ctx.db.insert("shareData", {
+          shareID: share._id,
+          dataType: item.type,
+          dataID,
+          payload,
+          createdAt: Date.now(),
+        })
+      }
+
+      // Update share title/model if provided
+      if (item.type === "session") {
+        const sessionData = item.data
+        if (sessionData?.title) {
+          await ctx.db.patch(share._id, {
+            title: sessionData.title,
+            updatedAt: Date.now(),
+          })
+        }
+      }
+    }
+
+    // Update share timestamp
+    await ctx.db.patch(share._id, {
+      updatedAt: Date.now(),
+    })
+
+    return { success: true }
+  },
+})
+
+export const remove = mutation({
+  args: {
+    slug: v.string(),
+    secret: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const share = await ctx.db
+      .query("shares")
+      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
+      .first()
+
+    if (!share || share.secret !== args.secret) {
+      throw new Error("Share not found or invalid secret")
+    }
+
+    // Soft delete
+    await ctx.db.patch(share._id, {
+      isDeleted: true,
+      updatedAt: Date.now(),
+    })
+
+    return { success: true }
+  },
+})
+
+export const get = query({
+  args: {
+    slug: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const share = await ctx.db
+      .query("shares")
+      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
+      .first()
+
+    if (!share || share.isDeleted || !share.isPublic) {
+      return null
+    }
+
+    // Get all share data
+    const data = await ctx.db
+      .query("shareData")
+      .withIndex("by_share", (q) => q.eq("shareID", share._id))
+      .collect()
+
+    return {
+      id: share.slug,
+      sessionID: share.sessionID,
+      title: share.title,
+      model: share.model,
+      createdAt: share.createdAt,
+      updatedAt: share.updatedAt,
+      data: data.map((d) => ({
+        type: d.dataType,
+        id: d.dataID,
+        data: JSON.parse(d.payload),
+      })),
+    }
+  },
+})
+
+export const getPublic = query({
+  args: {
+    slug: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Reuse get logic
+    const share = await ctx.db
+      .query("shares")
+      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
+      .first()
+
+    if (!share || share.isDeleted || !share.isPublic) {
+      return null
+    }
+
+    // Get all share data
+    const data = await ctx.db
+      .query("shareData")
+      .withIndex("by_share", (q) => q.eq("shareID", share._id))
+      .collect()
+
+    return {
+      id: share.slug,
+      sessionID: share.sessionID,
+      title: share.title,
+      model: share.model,
+      createdAt: share.createdAt,
+      updatedAt: share.updatedAt,
+      data: data.map((d) => ({
+        type: d.dataType,
+        id: d.dataID,
+        data: JSON.parse(d.payload),
+      })),
+    }
+  },
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jonsoc/convex",
-  "version": "1.1.46",
+  "version": "1.1.51",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -17,15 +17,15 @@
     "check-types": "tsc --noEmit"
   },
   "dependencies": {
-    "@convex-dev/better-auth": "catalog:",
-    "better-auth": "catalog:",
-    "convex": "catalog:",
-    "zod": "catalog:"
+    "@convex-dev/better-auth": "0.10.10",
+    "better-auth": "1.4.9",
+    "convex": "1.31.7",
+    "zod": "4.1.8"
   },
   "devDependencies": {
-    "@jonsoc/config": "workspace:*",
-    "@types/node": "catalog:",
-    "typescript": "catalog:"
+    "@jonsoc/config": "1.1.51",
+    "@types/node": "22.13.9",
+    "typescript": "5.8.2"
   },
   "publishConfig": {
     "access": "public"