create-vexcms 0.0.19 → 0.1.0-alpha.2

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

@@ -1,321 +0,0 @@
-import type { DataModel } from "@convex/_generated/dataModel"
-import type { GenericQueryCtx, TableNamesInDataModel } from "convex/server"
-
-import { mutation, query } from "@convex/_generated/server"
-import { findCollectionBySlug, hasPermission } from "@vexcms/core"
-import { paginationOptsValidator } from "convex/server"
-import { ConvexError, v } from "convex/values"
-
-import { TABLE_SLUG_USERS } from "~/db/constants"
-
-import config from "../../vex.config"
-import { access } from "../../src/vexcms/access"
-import * as Collections from "./model/collections"
-
-function requireCollection(slug: string) {
-  const match = findCollectionBySlug({ slug, config })
-  if (!match) {
-    throw new ConvexError(`Collection not found: ${slug}`)
-  }
-  return match
-}
-
-/**
- * Try to get the current user. Returns null if not authenticated.
- * Use this for queries where auth is optional (read filtering).
- */
-async function getUser(ctx: GenericQueryCtx<DataModel>) {
-  const identity = await ctx.auth.getUserIdentity()
-  if (!identity?.email) return null
-
-  const user = await ctx.db
-    .query(TABLE_SLUG_USERS)
-    .withIndex("by_email", (q) => q.eq("email", identity.email!))
-    .first()
-
-  if (!user) return null
-
-  return {
-    user: user as Record<string, unknown>,
-    roles: (user.role as string[]) ?? [],
-  }
-}
-
-/**
- * Get the current user, throwing if not authenticated.
- * Use this for mutations where auth is required.
- */
-async function requireUser(ctx: GenericQueryCtx<DataModel>) {
-  const result = await getUser(ctx)
-  if (!result) {
-    throw new ConvexError("Not authenticated")
-  }
-  return result
-}
-
-/**
- * Check permission and throw ConvexError if denied.
- * Error message includes which roles would grant the permission.
- */
-function checkPermission(props: Parameters<typeof hasPermission>[0]) {
-  const result = hasPermission(props)
-  const denied =
-    result === false ||
-    (typeof result === "object" && !Object.values(result).some(Boolean))
-
-  if (denied) {
-    const grantingRoles: string[] = []
-    if (props.access) {
-      for (const role of props.access.roles) {
-        const check = hasPermission({ ...props, userRoles: [role] })
-        const allowed =
-          check === true ||
-          (typeof check === "object" && Object.values(check).some(Boolean))
-        if (allowed) grantingRoles.push(role)
-      }
-    }
-
-    const rolesHint =
-      grantingRoles.length > 0
-        ? ` Requires one of: ${grantingRoles.join(", ")}`
-        : ""
-    throw new ConvexError(
-      `Access denied: "${props.action}" on "${props.resource}".${rolesHint}`,
-    )
-  }
-
-  return result
-}
-
-export const listDocuments = query({
-  args: {
-    collectionSlug: v.string(),
-    order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
-    paginationOpts: paginationOptsValidator,
-  },
-  handler: async (ctx, args) => {
-    const result = await Collections.listDocuments<DataModel>({
-      args: {
-        collectionSlug: args.collectionSlug as TableNamesInDataModel<DataModel>,
-        order: args.order,
-        paginationOpts: args.paginationOpts,
-      },
-      ctx,
-    })
-
-    // Filter by read permission if user is authenticated
-    const auth = await getUser(ctx)
-    if (!auth) return result
-
-    const filteredPage = result.page.filter((doc: Record<string, unknown>) => {
-      const readAllowed = hasPermission({
-        access,
-        user: auth.user,
-        userRoles: auth.roles,
-        resource: args.collectionSlug,
-        action: "read",
-        data: doc,
-      })
-      return readAllowed === true
-    })
-
-    return { ...result, page: filteredPage }
-  },
-})
-
-export const countDocuments = query({
-  args: { collectionSlug: v.string() },
-  handler: async (ctx, { collectionSlug }) => {
-    return await Collections.countDocuments<DataModel>({
-      args: { collectionSlug: collectionSlug as TableNamesInDataModel<DataModel> },
-      ctx,
-    })
-  },
-})
-
-export const getDocument = query({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-    preview: v.optional(v.boolean()),
-  },
-  handler: async (ctx, { collectionSlug, documentId, preview }) => {
-    const doc = await Collections.getDocument<DataModel>({
-      args: {
-        collectionSlug: collectionSlug as TableNamesInDataModel<DataModel>,
-        documentId,
-        preview,
-      },
-      ctx,
-    })
-
-    if (doc) {
-      const auth = await getUser(ctx)
-      if (auth) {
-        const readAllowed = hasPermission({
-          access,
-          user: auth.user,
-          userRoles: auth.roles,
-          resource: collectionSlug,
-          action: "read",
-          data: doc as Record<string, unknown>,
-        })
-        if (readAllowed !== true) return null
-      }
-    }
-
-    return doc
-  },
-})
-
-export const updateDocument = mutation({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-    fields: v.any(),
-  },
-  handler: async (ctx, { collectionSlug, documentId, fields }) => {
-    const match = requireCollection(collectionSlug)
-    const { user, roles } = await requireUser(ctx)
-
-    const fieldNames = Object.keys(fields as Record<string, unknown>)
-    checkPermission({
-      access,
-      user,
-      userRoles: roles,
-      resource: collectionSlug,
-      action: "update",
-      fields: fieldNames,
-      data: fields as Record<string, unknown>,
-    })
-
-    return await Collections.updateDocument<DataModel>({
-      args: {
-        collectionFields: match.fields,
-        collectionSlug: collectionSlug as TableNamesInDataModel<DataModel>,
-        documentId,
-        fields: fields as Record<string, unknown>,
-      },
-      ctx,
-    })
-  },
-})
-
-export const createDocument = mutation({
-  args: {
-    collectionSlug: v.string(),
-    fields: v.any(),
-  },
-  handler: async (ctx, { collectionSlug, fields }) => {
-    const match = requireCollection(collectionSlug)
-    const { user, roles } = await requireUser(ctx)
-
-    const fieldNames = Object.keys(fields as Record<string, unknown>)
-    checkPermission({
-      access,
-      user,
-      userRoles: roles,
-      resource: collectionSlug,
-      action: "create",
-      fields: fieldNames,
-      data: fields as Record<string, unknown>,
-    })
-
-    return await Collections.createDocument<DataModel>({
-      args: {
-        collectionFields: match.fields,
-        collectionSlug: collectionSlug as TableNamesInDataModel<DataModel>,
-        fields: fields as Record<string, unknown>,
-        kind: match.kind,
-      },
-      ctx,
-    })
-  },
-})
-
-export const deleteDocument = mutation({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-  },
-  handler: async (ctx, { collectionSlug, documentId }) => {
-    const match = requireCollection(collectionSlug)
-    const { user, roles } = await requireUser(ctx)
-
-    checkPermission({
-      access,
-      user,
-      userRoles: roles,
-      resource: collectionSlug,
-      action: "delete",
-    })
-
-    await Collections.deleteDocument<DataModel>({
-      args: {
-        collectionSlug: collectionSlug as TableNamesInDataModel<DataModel>,
-        documentId,
-        kind: match.kind,
-      },
-      ctx,
-    })
-  },
-})
-
-export const bulkDeleteDocuments = mutation({
-  args: {
-    collectionSlug: v.string(),
-    documentIds: v.array(v.string()),
-  },
-  handler: async (ctx, { collectionSlug, documentIds }) => {
-    const { user, roles } = await requireUser(ctx)
-
-    checkPermission({
-      access,
-      user,
-      userRoles: roles,
-      resource: collectionSlug,
-      action: "delete",
-    })
-
-    return await Collections.bulkDeleteDocuments<DataModel>({
-      args: { documentIds },
-      ctx,
-    })
-  },
-})
-
-export const searchDocuments = query({
-  args: {
-    collectionSlug: v.string(),
-    query: v.string(),
-    searchField: v.string(),
-    searchIndexName: v.string(),
-  },
-  handler: async (ctx, { collectionSlug, query: searchQuery, searchField, searchIndexName }) => {
-    const results = await Collections.searchDocuments<DataModel>({
-      args: {
-        collectionSlug: collectionSlug as TableNamesInDataModel<DataModel>,
-        query: searchQuery,
-        searchField,
-        searchIndexName,
-      },
-      ctx,
-    })
-
-    // Filter by read permission if user is authenticated
-    const auth = await getUser(ctx)
-    if (!auth) return results
-
-    return (results as Record<string, unknown>[]).filter((doc) => {
-      const readAllowed = hasPermission({
-        access,
-        user: auth.user,
-        userRoles: auth.roles,
-        resource: collectionSlug,
-        action: "read",
-        data: doc,
-      })
-      return readAllowed === true
-    })
-  },
-})

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

@@ -1,33 +0,0 @@
-import { createVexQuery } from "@vexcms/core"
-
-import { query } from "../_generated/server"
-
-/**
- * Typed vexQuery builder — use this instead of `query` for queries
- * that need draft/snapshot support (live preview, versioning).
- *
- * Automatically adds `_vexDrafts` arg and provides `ctx.drafts`
- * with full return type inference from your DataModel.
- *
- * @example
- * ```ts
- * import { vexQuery } from "./vex/helpers"
- * import { getPreviewSnapshot } from "@vexcms/core"
- *
- * export const getBySlug = vexQuery({
- *   args: { slug: v.string() },
- *   handler: async (ctx, args) => {
- *     const doc = await ctx.db.query("pages")
- *       .withIndex("by_slug", (q) => q.eq("slug", args.slug))
- *       .first()
- *     if (!doc) return null
- *     if (ctx.drafts === "snapshot") {
- *       const snapshot = await getPreviewSnapshot({ ctx, collection: "pages", documentId: doc._id })
- *       if (snapshot) return { ...doc, ...snapshot }
- *     }
- *     return doc
- *   },
- * })
- * ```
- */
-export const vexQuery = createVexQuery(query)

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

@@ -1,51 +0,0 @@
-import type { DataModel } from "@convex/_generated/dataModel"
-import type { GenericQueryCtx } from "convex/server"
-
-import { query } from "@convex/_generated/server"
-
-import { TABLE_SLUG_USERS } from "~/db/constants"
-
-import { access } from "../../src/vexcms/access"
-
-async function getUser(ctx: GenericQueryCtx<DataModel>) {
-  const identity = await ctx.auth.getUserIdentity()
-  if (!identity?.email) return null
-
-  const user = await ctx.db
-    .query(TABLE_SLUG_USERS)
-    .withIndex("by_email", (q) => q.eq("email", identity.email!))
-    .first()
-
-  return user ?? null
-}
-
-/**
- * List users available for impersonation.
- * Only accessible by users with adminRoles.
- */
-export const listImpersonatableUsers = query({
-  args: {},
-  handler: async (ctx) => {
-    const currentUser = await getUser(ctx)
-    if (!currentUser) return []
-
-    const roles = (currentUser.role as string[]) ?? []
-
-    // Check if user has an adminRole
-    const isAdmin = roles.some((r) => access.adminRoles.includes(r))
-    if (!isAdmin) return []
-
-    // Fetch all users except the current one
-    const allUsers = await ctx.db.query(TABLE_SLUG_USERS).collect()
-
-    return allUsers
-      .filter((u) => u._id !== currentUser._id)
-      .map((u) => ({
-        id: u._id as string,
-        name: u.name as string,
-        email: u.email as string,
-        avatar: (u.image as string) ?? undefined,
-        roles: (u.role as string[]) ?? [],
-      }))
-  },
-})

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

@@ -1,74 +0,0 @@
-import { mutation } from "../_generated/server";
-import { v } from "convex/values";
-
-/**
- * Generic backfill mutation called by the Vex CLI during auto-migration.
- * Patches existing documents that are missing a field with a default value.
- *
- * The CLI calls this in a loop with cursor pagination until `isDone` is true.
- */
-export const backfillField = mutation({
-  args: {
-    table: v.string(),
-    field: v.string(),
-    value: v.any(),
-    cursor: v.optional(v.string()),
-    batchSize: v.optional(v.number()),
-  },
-  handler: async (ctx, { table, field, value, cursor, batchSize = 100 }) => {
-    const results = await ctx.db
-      .query(table as any)
-      .paginate({ cursor: cursor ?? null, numItems: batchSize });
-
-    let patched = 0;
-    for (const doc of results.page) {
-      if ((doc as any)[field] === undefined) {
-        await ctx.db.patch(doc._id, { [field]: value } as any);
-        patched++;
-      }
-    }
-
-    return {
-      patched,
-      isDone: results.isDone,
-      cursor: results.continueCursor,
-    };
-  },
-});
-
-/**
- * Generic field removal mutation called by the Vex CLI during auto-migration.
- * Unsets a field from existing documents so the new schema (without the field)
- * can be deployed without validation errors.
- *
- * The CLI calls this in a loop with cursor pagination until `isDone` is true.
- */
-export const removeField = mutation({
-  args: {
-    table: v.string(),
-    field: v.string(),
-    cursor: v.optional(v.string()),
-    batchSize: v.optional(v.number()),
-  },
-  handler: async (ctx, { table, field, cursor, batchSize = 100 }) => {
-    const results = await ctx.db
-      .query(table as any)
-      .paginate({ cursor: cursor ?? null, numItems: batchSize });
-
-    let patched = 0;
-    for (const doc of results.page) {
-      if ((doc as any)[field] !== undefined) {
-        // Replace the entire document without the removed field
-        const { _id, _creationTime, [field]: _removed, ...rest } = doc as any;
-        await ctx.db.replace(_id, rest);
-        patched++;
-      }
-    }
-
-    return {
-      patched,
-      isDone: results.isDone,
-      cursor: results.continueCursor,
-    };
-  },
-});

package/templates/base-nextjs/convex/vex/model/collections.ts

@@ -1,196 +0,0 @@
-import type {
-  GenericDataModel,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  PaginationOptions,
-  TableNamesInDataModel,
-} from "convex/server"
-
-import { ConvexError } from "convex/values"
-import { generateFormSchema, getPreviewSnapshot } from "@vexcms/core"
-import type { VexField, CollectionKind } from "@vexcms/core"
-
-async function resolveStorageUrl(
-  ctx: { storage: { getUrl: (id: any) => Promise<string | null> } },
-  doc: any,
-) {
-  if (doc?.storageId) {
-    const url = await ctx.storage.getUrl(doc.storageId)
-    if (url) return { ...doc, url }
-  }
-  return doc
-}
-
-export async function listDocuments<DataModel extends GenericDataModel>(props: {
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    paginationOpts: PaginationOptions
-    order?: "asc" | "desc"
-  }
-  ctx: GenericQueryCtx<DataModel>
-}) {
-  const { args, ctx } = props
-  const q = args.order === "desc"
-    ? ctx.db.query(args.collectionSlug).order("desc")
-    : ctx.db.query(args.collectionSlug)
-  const result = await q.paginate(args.paginationOpts)
-  const resolvedPage = await Promise.all(
-    result.page.map((doc: any) => resolveStorageUrl(ctx, doc)),
-  )
-  return { ...result, page: resolvedPage }
-}
-
-export async function countDocuments<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  args: { collectionSlug: TableNamesInDataModel<DataModel> }
-}): Promise<number> {
-  return await (props.ctx.db.query(props.args.collectionSlug) as any).count()
-}
-
-export async function getDocument<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    documentId: string
-    /** When true, merges the transient preview snapshot (from admin live preview) */
-    preview?: boolean
-  }
-}) {
-  const doc = await props.ctx.db.get(props.args.documentId as any)
-  if (!doc) return null
-  const resolved = await resolveStorageUrl(props.ctx, doc)
-
-  // Merge preview snapshot when explicitly requested (live preview iframe).
-  if (props.args.preview) {
-    const snapshot = await getPreviewSnapshot<DataModel>({
-      ctx: props.ctx,
-      collection: props.args.collectionSlug as string,
-      documentId: props.args.documentId,
-    })
-    if (snapshot) {
-      return { ...resolved, ...snapshot }
-    }
-  }
-
-  return resolved
-}
-
-export async function updateDocument<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    documentId: string
-    fields: Record<string, unknown>
-    collectionFields: Record<string, VexField>
-  }
-}) {
-  const f = { ...props.args.fields }
-
-  // Resolve the file URL from storageId when replacing a media file
-  if (f.storageId && f.url === "") {
-    const url = await props.ctx.storage.getUrl(f.storageId as any)
-    if (url) f.url = url
-  }
-
-  const schema = generateFormSchema({
-    fields: props.args.collectionFields,
-  }).partial()
-
-  const result = schema.safeParse(f)
-  if (!result.success) {
-    throw new ConvexError({
-      message: "Validation failed",
-      errors: result.error.flatten(),
-    })
-  }
-
-  await props.ctx.db.patch(props.args.documentId as any, result.data as any)
-  return props.args.documentId
-}
-
-export async function createDocument<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    fields: Record<string, unknown>
-    collectionFields: Record<string, VexField>
-    kind: CollectionKind
-  }
-}): Promise<string> {
-  if (props.args.kind === "global") {
-    const existing = await props.ctx.db.query(props.args.collectionSlug).first()
-    if (existing) {
-      throw new ConvexError(
-        `Global "${props.args.collectionSlug}" already exists. Globals can only have one document.`,
-      )
-    }
-  }
-
-  const schema = generateFormSchema({
-    fields: props.args.collectionFields,
-  })
-
-  const result = schema.safeParse(props.args.fields)
-  if (!result.success) {
-    throw new ConvexError({
-      message: "Validation failed",
-      errors: result.error.flatten(),
-    })
-  }
-
-  const data = result.data as Record<string, unknown>
-  // Default vex_status to "published" for all user collections
-  if (!data.vex_status) {
-    data.vex_status = "published"
-  }
-  const id = await props.ctx.db.insert(props.args.collectionSlug as any, data as any)
-  return id as string
-}
-
-export async function deleteDocument<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    documentId: string
-    kind: CollectionKind
-  }
-}): Promise<void> {
-  if (props.args.kind === "global") {
-    const existing = await props.ctx.db.get(props.args.documentId as any)
-    if (!existing) {
-      throw new ConvexError(
-        `Global "${props.args.collectionSlug}" document not found. Cannot delete a non-existent global.`,
-      )
-    }
-  }
-
-  await props.ctx.db.delete(props.args.documentId as any)
-}
-
-export async function bulkDeleteDocuments<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  args: {
-    documentIds: string[]
-  }
-}): Promise<{ deleted: number }> {
-  for (const id of props.args.documentIds) {
-    await props.ctx.db.delete(id as any)
-  }
-  return { deleted: props.args.documentIds.length }
-}
-
-export async function searchDocuments<DataModel extends GenericDataModel>(props: {
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    searchIndexName: string
-    searchField: string
-    query: string
-  }
-  ctx: GenericQueryCtx<DataModel>
-}) {
-  const { args, ctx } = props
-  const docs = await (ctx.db.query(args.collectionSlug) as any)
-    .withSearchIndex(args.searchIndexName, (q: any) => q.search(args.searchField, args.query))
-    .take(50)
-  return Promise.all(docs.map((doc: any) => resolveStorageUrl(ctx, doc)))
-}