create-vexcms 0.0.3

package/templates/base-nextjs/convex/auth/db.ts

@@ -0,0 +1,303 @@
+import type { BetterAuthDBSchema } from "better-auth/db"
+import type { GenericId } from "convex/values"
+
+import { v } from "convex/values"
+
+import type { WhereClause } from "./adapter/utils"
+
+import { internalMutation, internalQuery } from "../_generated/server"
+import schema from "../schema"
+import { checkUniqueFields, listOne, paginate, selectFields } from "./adapter/utils"
+
+// Helper to get Better Auth schema - we'll pass it from the adapter
+const getBetterAuthSchema = (schemaJson: string): BetterAuthDBSchema => {
+  return JSON.parse(schemaJson)
+}
+
+// Create (insert) operation
+export const dbCreate = internalMutation({
+  args: {
+    betterAuthSchema: v.string(),
+    data: v.any(),
+    model: v.string(),
+    select: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, { betterAuthSchema, data, model, select }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+
+    // Check unique fields before insert
+    await checkUniqueFields(ctx, schema, authSchema, model, data)
+
+    const id = await ctx.db.insert(model as any, data)
+    const doc = await ctx.db.get(id)
+    if (!doc) {
+      throw new Error(`Failed to create ${model}`)
+    }
+
+    return selectFields(doc, select)
+  },
+})
+
+// Find one operation
+export const dbFindOne = internalQuery({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    select: v.optional(v.array(v.string())),
+    where: v.array(v.any()),
+  },
+  handler: async (ctx, { betterAuthSchema, model, select, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    // @ts-expect-error GenericCtx type is a superset
+    const result = await listOne(ctx, schema, authSchema, {
+      model,
+      select,
+      where: where as WhereClause[],
+    })
+
+    return result
+  },
+})
+
+// Find many operation
+export const dbFindMany = internalQuery({
+  args: {
+    betterAuthSchema: v.string(),
+    limit: v.optional(v.number()),
+    model: v.string(),
+    sortBy: v.optional(
+      v.object({
+        direction: v.union(v.literal("asc"), v.literal("desc")),
+        field: v.string(),
+      })
+    ),
+    where: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, { betterAuthSchema, limit, model, sortBy, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = (where ?? []) as WhereClause[]
+
+    // Handle OR connector by running parallel queries
+    if (parsedWhere.some((w) => w.connector === "OR")) {
+      const results = await Promise.all(
+        parsedWhere.map(async (w) => {
+          // @ts-expect-error GenericCtx type is a superset
+          const result = await paginate(ctx, schema, authSchema, {
+            model,
+            paginationOpts: { cursor: null, numItems: limit ?? 200 },
+            sortBy,
+            where: [w],
+          })
+          return result.page
+        })
+      )
+
+      // De-duplicate and flatten
+      const seen = new Set<string>()
+      const uniqueDocs: any[] = []
+      for (const docs of results) {
+        for (const doc of docs) {
+          const docId = doc._id as string
+          if (!seen.has(docId)) {
+            seen.add(docId)
+            uniqueDocs.push(doc)
+          }
+        }
+      }
+
+      // Apply sorting if needed
+      if (sortBy) {
+        uniqueDocs.sort((a, b) => {
+          const aVal = a[sortBy.field]
+          const bVal = b[sortBy.field]
+          if (aVal === bVal) {
+            return 0
+          }
+          const comparison = aVal > bVal ? 1 : -1
+          return sortBy.direction === "desc" ? -comparison : comparison
+        })
+      }
+
+      return uniqueDocs.slice(0, limit)
+    }
+
+    // Normal case without OR
+    // @ts-expect-error GenericCtx type is a superset
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: limit ?? 200 },
+      sortBy,
+      where: parsedWhere,
+    })
+
+    return result.page
+  },
+})
+
+// Count operation
+export const dbCount = internalQuery({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = (where ?? []) as WhereClause[]
+
+    // Handle OR connector
+    if (parsedWhere.some((w) => w.connector === "OR")) {
+      const results = await Promise.all(
+        parsedWhere.map(async (w) => {
+          // @ts-expect-error GenericCtx type is a superset
+          const result = await paginate(ctx, schema, authSchema, {
+            model,
+            paginationOpts: { cursor: null, numItems: 200 },
+            where: [w],
+          })
+          return result.page
+        })
+      )
+
+      // De-duplicate and count
+      const seen = new Set<string>()
+      for (const docs of results) {
+        for (const doc of docs) {
+          const docId = doc._id as string
+          seen.add(docId)
+        }
+      }
+      return seen.size
+    }
+
+    // Normal case
+    // @ts-expect-error GenericCtx type is a superset
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere,
+    })
+
+    return result.page.length
+  },
+})
+
+// Update operation
+export const dbUpdate = internalMutation({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    update: v.any(),
+    where: v.array(v.any()),
+  },
+  handler: async (ctx, { betterAuthSchema, model, update, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = where as WhereClause[]
+
+    // Find the document to update
+    const doc = await listOne(ctx, schema, authSchema, {
+      model,
+      where: parsedWhere,
+    })
+
+    if (!doc) {
+      return null
+    }
+
+    // Check unique fields before update
+    await checkUniqueFields(ctx, schema, authSchema, model, update, doc)
+
+    await ctx.db.patch(doc._id as GenericId<any>, update)
+    return await ctx.db.get(doc._id as GenericId<any>)
+  },
+})
+
+// Update many operation
+export const dbUpdateMany = internalMutation({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    update: v.any(),
+    where: v.array(v.any()),
+  },
+  handler: async (ctx, { betterAuthSchema, model, update, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = where as WhereClause[]
+
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere,
+    })
+
+    // Check unique fields if updating multiple docs
+    if (result.page.length > 1) {
+      const uniqueFieldKeys = Object.keys(update).filter(
+        (key) => authSchema[model]?.fields?.[key]?.unique
+      )
+      if (uniqueFieldKeys.length > 0) {
+        throw new Error(
+          `Attempted to set unique fields in multiple documents in ${model} with the same value. Fields: ${uniqueFieldKeys.join(", ")}`
+        )
+      }
+    }
+
+    // Update each document
+    for (const doc of result.page) {
+      await checkUniqueFields(ctx, schema, authSchema, model, update, doc)
+      await ctx.db.patch(doc._id as GenericId<any>, update)
+    }
+
+    return result.page.length
+  },
+})
+
+// Delete operation
+export const dbDelete = internalMutation({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.array(v.any()),
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = where as WhereClause[]
+
+    const doc = await listOne(ctx, schema, authSchema, {
+      model,
+      where: parsedWhere,
+    })
+
+    if (!doc) {
+      return
+    }
+
+    await ctx.db.delete(doc._id as GenericId<any>)
+  },
+})
+
+// Delete many operation
+export const dbDeleteMany = internalMutation({
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.array(v.any()),
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema)
+    const parsedWhere = where as WhereClause[]
+
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere,
+    })
+
+    // Delete each document
+    for (const doc of result.page) {
+      await ctx.db.delete(doc._id as GenericId<any>)
+    }
+
+    return result.page.length
+  },
+})

package/templates/base-nextjs/convex/auth/index.ts

@@ -0,0 +1,14 @@
+import type { GenericActionCtx } from "convex/server"
+
+import { betterAuth } from "better-auth"
+
+import type { DataModel } from "../_generated/dataModel"
+
+import { buildBetterAuthOptions } from "./options"
+
+export const createAuth = (
+  ctx: GenericActionCtx<DataModel>,
+  { optionsOnly } = { optionsOnly: false }
+) => {
+  return betterAuth(buildBetterAuthOptions({ ctx, optionsOnly }))
+}

package/templates/base-nextjs/convex/auth/options.ts

@@ -0,0 +1,63 @@
+import { type DataModel } from "@convex/_generated/dataModel"
+import schema from "@convex/schema"
+import { type BetterAuthOptions } from "better-auth"
+import { type GenericActionCtx } from "convex/server"
+
+import {
+  TABLE_SLUG_ACCOUNTS,
+  TABLE_SLUG_SESSIONS,
+  TABLE_SLUG_USERS,
+  TABLE_SLUG_VERIFICATIONS,
+  USER_ROLES,
+} from "~/db/constants"
+
+import { convexAdapter } from "./adapter"
+import betterAuthPlugins from "./plugins"
+
+export const betterAuthOptions: BetterAuthOptions = {
+  account: {
+    modelName: TABLE_SLUG_ACCOUNTS,
+  },
+  baseURL: process.env.SITE_URL,
+  // {{EMAIL_PASSWORD_AUTH}}
+  // {{OAUTH_PROVIDERS}}
+  logger: {
+    disabled: false,
+  },
+  plugins: betterAuthPlugins,
+  secret: process.env.BETTER_AUTH_SECRET,
+  session: {
+    modelName: TABLE_SLUG_SESSIONS,
+  },
+  trustedOrigins: [process.env.SITE_URL!],
+  user: {
+    additionalFields: {
+      role: {
+        type: "string[]",
+        defaultValue: [USER_ROLES.user],
+        required: true,
+      },
+    },
+    modelName: TABLE_SLUG_USERS,
+  },
+  verification: {
+    modelName: TABLE_SLUG_VERIFICATIONS,
+  },
+}
+
+export function buildBetterAuthOptions({
+  ctx,
+  optionsOnly = false,
+}: {
+  ctx: GenericActionCtx<DataModel>
+  optionsOnly?: boolean
+}) {
+  return {
+    ...betterAuthOptions,
+    database: convexAdapter(ctx, schema),
+    logger: {
+      ...betterAuthOptions.logger,
+      disabled: optionsOnly,
+    },
+  }
+}

package/templates/base-nextjs/convex/auth/plugins/index.ts

@@ -0,0 +1,20 @@
+import { convex } from "@convex-dev/better-auth/plugins"
+import authConfig from "@convex/auth.config"
+import { nextCookies } from "better-auth/next-js"
+import { admin, apiKey } from "better-auth/plugins"
+// {{ORGANIZATIONS_IMPORT}}
+
+import { USER_ROLES } from "~/db/constants"
+
+const plugins = [
+  admin({
+    adminRoles: [USER_ROLES.admin],
+    defaultRole: USER_ROLES.user,
+  }),
+  apiKey(),
+  convex({ authConfig }),
+  nextCookies(),
+  // {{ORGANIZATIONS_PLUGIN}}
+]
+
+export default plugins

package/templates/base-nextjs/convex/auth/sessions.ts

@@ -0,0 +1,60 @@
+import { v } from "convex/values"
+
+import { TABLE_SLUG_SESSIONS, type TABLE_SLUG_USERS } from "~/db/constants"
+
+import type { Id } from "../_generated/dataModel"
+
+import { query } from "../_generated/server"
+
+/**
+ * Get session with user data by session token
+ * Used for server-side authentication in Next.js
+ */
+export const getSessionWithUser = query({
+  args: {
+    sessionToken: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Find the session by token
+    const session = await ctx.db
+      .query(TABLE_SLUG_SESSIONS)
+      .withIndex("by_token", (q) => q.eq("token", args.sessionToken))
+      .first()
+
+    if (!session) {
+      return null
+    }
+
+    // Check if session is expired
+    if (session.expiresAt < Date.now()) {
+      console.error("Session Expired")
+      return null
+    }
+
+    // Get the user data
+    const user = await ctx.db.get(session.userId as Id<typeof TABLE_SLUG_USERS>)
+
+    if (!user) {
+      return null
+    }
+
+    return {
+      session: {
+        id: session._id,
+        expiresAt: session.expiresAt,
+        ipAddress: session.ipAddress,
+        token: session.token,
+        userAgent: session.userAgent,
+        userId: session.userId,
+      },
+      user: {
+        id: user._id,
+        name: user.name,
+        email: user.email,
+        emailVerified: user.emailVerified,
+        image: user.image,
+        role: user.role,
+      },
+    }
+  },
+})

package/templates/base-nextjs/convex/auth.config.ts

@@ -0,0 +1,7 @@
+import type { AuthConfig } from "convex/server"
+
+import { getAuthConfigProvider } from "@convex-dev/better-auth/auth-config"
+
+export default {
+  providers: [getAuthConfigProvider()],
+} satisfies AuthConfig

package/templates/base-nextjs/convex/convex.config.ts

@@ -0,0 +1,5 @@
+import { defineApp } from "convex/server"
+
+const app = defineApp()
+
+export default app

package/templates/base-nextjs/convex/http.ts

@@ -0,0 +1,28 @@
+import { httpRouter } from "convex/server"
+
+import { httpAction } from "./_generated/server"
+import { createAuth } from "./auth"
+
+const http = httpRouter()
+
+// Auth request handler - basePath hardcoded to /api/auth for now
+const authRequestHandler = httpAction(async (ctx, request) => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const auth = createAuth(ctx)
+  return await auth.handler(request)
+})
+
+// Register auth routes for GET and POST
+http.route({
+  handler: authRequestHandler,
+  method: "GET",
+  pathPrefix: "/api/auth/",
+})
+
+http.route({
+  handler: authRequestHandler,
+  method: "POST",
+  pathPrefix: "/api/auth/",
+})
+
+export default http

package/templates/base-nextjs/convex/schema.ts

@@ -0,0 +1,3 @@
+import { defineSchema } from "convex/server"
+
+export default defineSchema({})

package/templates/base-nextjs/convex/vex/auth.ts

@@ -0,0 +1,38 @@
+import type { VexQueryCtx } from "@vexcms/core"
+
+import { TABLE_SLUG_USERS } from "~/db/constants"
+
+import type { MutationCtx, QueryCtx } from "../_generated/server"
+
+export type UserAuth = {
+  roles: string[]
+  user: Record<string, unknown>
+}
+
+/**
+ * Returns the authenticated user and their roles, or null if unauthenticated.
+ * Called by all generated collection query and mutation files.
+ */
+export async function getUser(ctx: QueryCtx): Promise<null | UserAuth>
+export async function getUser(ctx: MutationCtx): Promise<null | UserAuth>
+export async function getUser(ctx: VexQueryCtx): Promise<null | UserAuth>
+export async function getUser(ctx: MutationCtx | QueryCtx | VexQueryCtx): Promise<null | UserAuth> {
+  const identity = await ctx.auth.getUserIdentity()
+  if (!identity?.email) {
+    return null
+  }
+
+  const user = await (ctx.db as QueryCtx["db"])
+    .query(TABLE_SLUG_USERS)
+    .withIndex("by_email", (q) => q.eq("email", identity.email!))
+    .first()
+
+  if (!user) {
+    return null
+  }
+
+  return {
+    roles: (user.role as string[]) ?? [],
+    user: user as Record<string, unknown>,
+  }
+}