create-vexcms 0.0.19 → 0.1.0-alpha.2

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

@@ -1,87 +0,0 @@
-import type {
-  GenericDataModel,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  PaginationOptions,
-  TableNamesInDataModel,
-} from "convex/server"
-
-import { ConvexError } from "convex/values"
-import { generateFormSchema } from "@vexcms/core"
-import type { VexField } from "@vexcms/core"
-
-export async function createMediaDocument<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    fields: Record<string, unknown>
-    collectionFields: Record<string, VexField>
-  }
-}): Promise<string> {
-  const f = { ...props.args.fields }
-
-  // Extract system fields that bypass form schema validation
-  const storageId = f.storageId
-  delete f.storageId
-
-  // Resolve the file URL from storageId before inserting
-  if (storageId && (!f.url || f.url === "")) {
-    const url = await props.ctx.storage.getUrl(storageId as any)
-    if (url) f.url = url
-  }
-
-  const schema = generateFormSchema({
-    fields: props.args.collectionFields,
-  })
-
-  const result = schema.safeParse(f)
-  if (!result.success) {
-    throw new ConvexError({
-      message: "Validation failed",
-      errors: result.error.flatten(),
-    })
-  }
-
-  // Re-attach storageId for the DB insert
-  const data = { ...result.data, ...(storageId ? { storageId } : {}) } as any
-  const id = await props.ctx.db.insert(props.args.collectionSlug as any, data)
-  return id as string
-}
-
-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 paginatedSearchDocuments<DataModel extends GenericDataModel>(props: {
-  args: {
-    collectionSlug: TableNamesInDataModel<DataModel>
-    searchIndexName: string
-    searchField: string
-    query: string
-    paginationOpts: PaginationOptions
-  }
-  ctx: GenericQueryCtx<DataModel>
-}) {
-  const { args, ctx } = props
-
-  let result
-  if (args.query === "") {
-    result = await ctx.db.query(args.collectionSlug).paginate(args.paginationOpts)
-  } else {
-    result = await (ctx.db.query(args.collectionSlug))
-      .withSearchIndex(args.searchIndexName, (q) => q.search(args.searchField, args.query))
-      .paginate(args.paginationOpts)
-  }
-
-  const resolvedPage = await Promise.all(
-    result.page.map((doc: any) => resolveStorageUrl(ctx, doc)),
-  )
-  return { ...result, page: resolvedPage }
-}

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

@@ -1,254 +0,0 @@
-import type {
-  GenericDataModel,
-  GenericMutationCtx,
-  GenericQueryCtx,
-} from "convex/server"
-
-/**
- * Status values for version records.
- * - "draft": a saved draft
- * - "published": this snapshot was published to the main document
- * - "autosave": an autosave version (coalesced in-place)
- */
-export type VersionStatus = "draft" | "published" | "autosave"
-
-/**
- * Gets the next version number for a document.
- */
-export async function getNextVersionNumber<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  collection: string
-  documentId: string
-}): Promise<number> {
-  // Query all versions and find the highest version number.
-  // We can't just take the latest by createdAt because previewSnapshot
-  // entries have version: 0 and may have a later createdAt.
-  const allVersions = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document", (q: any) =>
-      q.eq("collection", props.collection).eq("documentId", props.documentId),
-    )
-    .collect()
-
-  let maxVersion = 0
-  for (const v of allVersions) {
-    const ver = v.version as number
-    if (ver > maxVersion) maxVersion = ver
-  }
-
-  return maxVersion + 1
-}
-
-/**
- * Creates a new version record in the vex_versions table.
- */
-export async function createVersion<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  collection: string
-  documentId: string
-  snapshot: Record<string, unknown>
-  status: VersionStatus
-  createdBy: string | null
-  restoredFrom?: number
-}): Promise<{ versionId: string; version: number }> {
-  const version = await getNextVersionNumber({
-    ctx: props.ctx,
-    collection: props.collection,
-    documentId: props.documentId,
-  })
-
-  const versionId = await (props.ctx.db as any).insert("vex_versions", {
-    collection: props.collection,
-    documentId: props.documentId,
-    version,
-    status: props.status,
-    snapshot: props.snapshot,
-    createdAt: Date.now(),
-    createdBy: props.createdBy ?? undefined,
-    isAutosave: props.status === "autosave",
-    restoredFrom: props.restoredFrom ?? undefined,
-  })
-
-  return { versionId: versionId as string, version }
-}
-
-/**
- * Gets the latest version for a document (any status).
- * Used by the admin edit view to load the most recent content.
- */
-export async function getLatestVersion<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  collection: string
-  documentId: string
-}): Promise<Record<string, unknown> | null> {
-  // Get all versions and find the one with the highest version number,
-  // excluding previewSnapshot and autosave entries.
-  const allVersions = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document", (q: any) =>
-      q.eq("collection", props.collection).eq("documentId", props.documentId),
-    )
-    .collect()
-
-  let latest: Record<string, unknown> | null = null
-  let maxVersion = -1
-  for (const v of allVersions) {
-    if (v.status === "previewSnapshot" || v.status === "autosave") continue
-    const ver = v.version as number
-    if (ver > maxVersion) {
-      maxVersion = ver
-      latest = v as Record<string, unknown>
-    }
-  }
-
-  return latest
-}
-
-/**
- * Gets the latest version with status "published" for a document.
- */
-export async function getLatestPublishedVersion<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  collection: string
-  documentId: string
-}): Promise<Record<string, unknown> | null> {
-  const latest = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document_status", (q: any) =>
-      q
-        .eq("collection", props.collection)
-        .eq("documentId", props.documentId)
-        .eq("status", "published"),
-    )
-    .order("desc")
-    .first()
-
-  return latest as Record<string, unknown> | null
-}
-
-/**
- * Lists all versions for a document, ordered newest first.
- * Excludes autosave versions from the list.
- */
-export async function listVersions<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  collection: string
-  documentId: string
-  limit?: number
-}): Promise<Record<string, unknown>[]> {
-  const versions = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document_latest", (q: any) =>
-      q.eq("collection", props.collection).eq("documentId", props.documentId),
-    )
-    .order("desc")
-    .take(props.limit ?? 50)
-
-  return (versions as Record<string, unknown>[])
-    .filter((v) => !v.isAutosave && v.status !== "previewSnapshot")
-    .map((v) => ({
-      _id: v._id,
-      version: v.version,
-      status: v.status,
-      createdAt: v.createdAt,
-      createdBy: v.createdBy,
-      isAutosave: v.isAutosave,
-      restoredFrom: v.restoredFrom ?? null,
-    }))
-}
-
-/**
- * Gets a specific version by version number.
- * Includes the full snapshot for restore preview.
- */
-export async function getVersion<DataModel extends GenericDataModel>(props: {
-  ctx: GenericQueryCtx<DataModel>
-  collection: string
-  documentId: string
-  version: number
-}): Promise<Record<string, unknown> | null> {
-  const version = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document_version", (q: any) =>
-      q
-        .eq("collection", props.collection)
-        .eq("documentId", props.documentId)
-        .eq("version", props.version),
-    )
-    .first()
-
-  return version as Record<string, unknown> | null
-}
-
-/**
- * Finds the latest autosave version for a document and updates it in-place.
- * If no autosave exists, creates a new one.
- */
-export async function coalesceAutosave<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  collection: string
-  documentId: string
-  snapshot: Record<string, unknown>
-  createdBy: string | null
-}): Promise<{ versionId: string; version: number }> {
-  const existing = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_autosave", (q: any) =>
-      q
-        .eq("collection", props.collection)
-        .eq("documentId", props.documentId)
-        .eq("isAutosave", true),
-    )
-    .order("desc")
-    .first()
-
-  if (existing) {
-    await (props.ctx.db as any).patch(existing._id, {
-      snapshot: props.snapshot,
-      createdAt: Date.now(),
-    })
-    return { versionId: existing._id as string, version: existing.version as number }
-  }
-
-  return createVersion({
-    ctx: props.ctx,
-    collection: props.collection,
-    documentId: props.documentId,
-    snapshot: props.snapshot,
-    status: "autosave",
-    createdBy: props.createdBy,
-  })
-}
-
-/**
- * Cleans up old versions exceeding the maxPerDoc limit.
- * Preserves all published versions regardless of limit.
- * Never deletes the most recent version.
- */
-export async function cleanupOldVersions<DataModel extends GenericDataModel>(props: {
-  ctx: GenericMutationCtx<DataModel>
-  collection: string
-  documentId: string
-  maxPerDoc: number
-}): Promise<void> {
-  if (props.maxPerDoc === 0) return
-
-  const allVersions = await (props.ctx.db as any)
-    .query("vex_versions")
-    .withIndex("by_document_latest", (q: any) =>
-      q.eq("collection", props.collection).eq("documentId", props.documentId),
-    )
-    .order("desc")
-    .collect()
-
-  if (allVersions.length <= props.maxPerDoc) return
-
-  const toKeep = allVersions.slice(0, props.maxPerDoc)
-  const candidates = allVersions.slice(props.maxPerDoc)
-
-  for (const candidate of candidates) {
-    // Always preserve published versions
-    if (candidate.status === "published") continue
-    await (props.ctx.db as any).delete(candidate._id)
-  }
-}

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

@@ -1,53 +0,0 @@
-import type { DataModel } from "@convex/_generated/dataModel"
-
-import { mutation, query } from "@convex/_generated/server"
-import {
-  upsertPreviewSnapshot,
-  deletePreviewSnapshot,
-  getPreviewSnapshot,
-} from "@vexcms/core"
-import { v } from "convex/values"
-
-export const upsert = mutation({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-    snapshot: v.any(),
-  },
-  handler: async (ctx, { collectionSlug, documentId, snapshot }) => {
-    await upsertPreviewSnapshot<DataModel>({
-      ctx,
-      collection: collectionSlug,
-      documentId,
-      snapshot: snapshot as Record<string, unknown>,
-    })
-  },
-})
-
-export const remove = mutation({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-  },
-  handler: async (ctx, { collectionSlug, documentId }) => {
-    await deletePreviewSnapshot<DataModel>({
-      ctx,
-      collection: collectionSlug,
-      documentId,
-    })
-  },
-})
-
-export const get = query({
-  args: {
-    collectionSlug: v.string(),
-    documentId: v.string(),
-  },
-  handler: async (ctx, { collectionSlug, documentId }) => {
-    return await getPreviewSnapshot<DataModel>({
-      ctx,
-      collection: collectionSlug,
-      documentId,
-    })
-  },
-})