Collections

import { f, defineVextroCollection } from "vextro";

export const posts = defineVextroCollection({
  // slug defaults to "posts" (the tableName)
  label: "Blog Posts",
  description: "Articles published on the company blog",
  group: "Content",
  collectionType: "content",
  tableName: "posts",
  useAsTitle: "title",
  fields: {
    title: f.text({ required: true, searchable: true, listColumn: true }),
    slug: f.slug({ sourceField: "title", required: true }),
    author: f.id("users", { required: true, listColumn: true }),
    excerpt: f.textarea({ rows: 3 }),
    content: f.richText(),
    featuredImage: f.image({ relationTo: "media" }),
    publishedAt: f.datetime({ sidebar: true, sidebarSection: "scheduling" }),
    category: f.select({
      options: ["news", "engineering", "tutorial", "announcement"],
      required: true,
      listColumn: true,
    }),
    featured: f.checkbox({ sidebar: true, sidebarSection: "document" }),
  },
  listConfig: {
    columns: ["title", "category", "status", "publishedAt"],
    searchableFields: ["title", "slug"],
    defaultSort: "publishedAt",
    defaultSortDirection: "desc",
  },
  access: {
    read: "cms:read",
    create: "cms:write",
    update: "cms:write",
    delete: "cms:admin",
  },
  versions: { enabled: true, maxVersions: 25 },
});

export const blogPosts = defineVextroCollection({
  slug: "blog",           // URL path uses "blog"
  tableName: "blog_posts", // Convex table is "blog_posts"
  label: "Blog Posts",
  collectionType: "content",
  fields: { /* ... */ },
});

export const employees = defineVextroCollection({
  label: "Employees",
  tableName: "employees",
  collectionType: "operational", // semantic label for sidebar grouping (any string)
  traits: {
    statusWorkflow: false,  // no draft/publish lifecycle
    autoTimestamps: true,   // auto-update updatedAt on mutations
    auditFields: true,      // track updatedBy and createdBy
    versioning: true,       // enable version history on save
    softDelete: false,      // hard delete (no trash)
  },
  fields: {
    name: f.text({ required: true }),
    department: f.select({ options: ["engineering", "marketing", "sales"] }),
  },
});

// These two are equivalent:
defineVextroCollection({
  collectionType: "content",
  // ...
});

defineVextroCollection({
  collectionType: "content",
  traits: { statusWorkflow: true, autoTimestamps: true, auditFields: true },
  // ...
});

// Override a preset: content type but without status workflow
defineVextroCollection({
  collectionType: "content",
  traits: { statusWorkflow: false },
  // ...
});

fields: {
  // Required text with search indexing
  title: f.text({ required: true, searchable: true }),

  // Auto-generated slug from another field
  slug: f.slug({ sourceField: "title", required: true }),

  // Relationship to another table
  author: f.id("users", { required: true }),

  // Select with labeled options
  priority: f.select({
    options: [
      { label: "Low", value: "low" },
      { label: "Medium", value: "medium" },
      { label: "High", value: "high" },
    ],
  }),

  // Conditional field: only visible when priority is "high"
  escalationNotes: f.textarea({
    condition: { field: "priority", equals: "high" },
  }),
}

fields: {
  status: f.select({
    sidebar: true,
    sidebarSection: "document",
    options: ["draft", "published", "scheduled", "trashed"],
  }),
  slug: f.slug({
    sourceField: "title",
    sidebar: true,
    sidebarSection: "document",
    copyable: true,
  }),
  publishAt: f.datetime({
    sidebar: true,
    sidebarSection: "scheduling",
  }),
}

defineVextroCollection({
  slug: "pages",
  tableName: "pages",
  fields: { /* ... */ },
  sidebarConfig: {
    sectionOrder: ["actions", "_default", "document", "activity"],
  },
});

listConfig: {
  columns: ["title", "status", "author", "publishedAt"],
  searchableFields: ["title", "slug", "excerpt"],
  defaultSort: "publishedAt",
  defaultSortDirection: "desc",
},

access: {
  read: "cms:read",
  create: "cms:write",
  update: "cms:write",
  delete: "cms:admin",
},

export const media = defineVextroCollection({
  label: "Media",
  tableName: "media",
  upload: {
    mimeTypes: ["image/*", "application/pdf"],
    maxFileSize: 10 * 1024 * 1024, // 10 MB
    imageSizes: [
      { name: "thumbnail", width: 200, height: 200 },
      { name: "card", width: 600 },
    ],
    focalPoint: true,
    crop: true,
    bulkUpload: true,
    displayPreview: true,
  },
  fields: {
    alt: f.text(),
    caption: f.textarea(),
  },
});

export const pages = defineVextroCollection({
  label: "Pages",
  tableName: "pages",
  collectionType: "content",
  preview: {
    url: "/preview/{slug}",
    enabled: true,
  },
  fields: {
    title: f.text({ required: true }),
    slug: f.slug({ sourceField: "title", required: true }),
    body: f.richText(),
  },
});

export const articles = defineVextroCollection({
  label: "Articles",
  tableName: "articles",
  collectionType: "content",
  workflow: {
    enabled: true,
    stages: [
      { name: "review", label: "Editorial Review" },
      { name: "legal", label: "Legal Approval" },
    ],
  },
  fields: {
    title: f.text({ required: true }),
    body: f.richText(),
  },
});

export const pages = defineVextroCollection({
  label: "Pages",
  tableName: "pages",
  localization: {
    enabled: true,
    locales: ["en", "es", "fr", "de"],
    defaultLocale: "en",
    localizedFields: ["title", "body", "excerpt"],
  },
  fields: {
    title: f.text({ required: true }),
    slug: f.slug({ sourceField: "title", required: true }),
    body: f.richText(),
    excerpt: f.textarea(),
    featuredImage: f.image({ relationTo: "media" }),
  },
});

export const categories = defineVextroCollection({
  label: "Categories",
  tableName: "categories",
  hierarchy: {
    parentField: "parent",
    maxDepth: 5,
  },
  fields: {
    name: f.text({ required: true }),
    parent: f.id("categories"),
  },
});

export const orders = defineVextroCollection({
  label: "Orders",
  tableName: "orders",
  hooks: {
    beforeChange: [
      async ({ data, operation, ctx }) => {
        if (operation === "create") {
          data.orderNumber = await generateOrderNumber(ctx);
        }
        return data;
      },
    ],
    afterChange: [
      async ({ doc, operation, ctx }) => {
        if (operation === "create") {
          await sendOrderConfirmation(ctx, doc);
        }
      },
    ],
    beforeDelete: [
      async ({ id, ctx }) => {
        await archiveOrderData(ctx, id);
      },
    ],
  },
  fields: {
    orderNumber: f.text(),
    total: f.number({ required: true }),
    items: f.json(),
  },
});

export const posts = defineVextroCollection({
  label: "Posts",
  tableName: "posts",
  autoSave: {
    enabled: true,
    debounceMs: 2000,
  },
  fields: {
    title: f.text({ required: true }),
    body: f.richText(),
  },
});

defineVextroCollection({
  slug: "drafts",
  label: "Drafts",
  tableName: "drafts",
  autoSave: true, // enabled, debounceMs: 3000
  fields: {
    title: f.text({ required: true }),
    content: f.richText(),
  },
});

export const articles = defineVextroCollection({
  label: "Articles",
  tableName: "articles",
  collectionType: "content",
  statusConfig: {
    field: "publishStatus",
    values: ["draft", "in_review", "published", "archived"],
    index: "by_publish_status",
  },
  fields: {
    title: f.text({ required: true }),
  },
});

export const products = defineVextroCollection({
  label: "Products",
  tableName: "products",
  fieldNames: {
    status: "productStatus",
    updatedAt: "lastModified",
    updatedBy: "modifiedBy",
    createdBy: "addedBy",
    slug: "urlKey",
  },
  fields: {
    name: f.text({ required: true }),
    urlKey: f.slug({ sourceField: "name", required: true }),
  },
});

export const internalSettings = defineVextroCollection({
  label: "Internal Settings",
  tableName: "internalSettings",
  sidebar: false, // hidden from sidebar navigation
  fields: {
    key: f.text({ required: true }),
    value: f.json(),
  },
});

export const products = defineVextroCollection({
  label: "Products",
  tableName: "products",
  indexes: [
    { name: "by_sku", fields: ["sku"] },
    { name: "by_category_price", fields: ["category", "price"] },
  ],
  fields: {
    sku: f.text({ required: true }),
    category: f.select({ options: ["electronics", "clothing", "home"] }),
    price: f.number({ required: true }),
  },
});

export const teamMembers = defineVextroCollection({
  label: "Team Members",
  tableName: "teamMembers",
  picker: {
    group: "People",
    thumbnail: "/images/team-icon.svg",
    icon: "👤",
  },
  fields: {
    name: f.text({ required: true }),
    role: f.text(),
  },
});

export const policies = defineVextroCollection({
  label: "Policies",
  tableName: "policies",
  versions: {
    enabled: true,
    maxVersions: 50,
  },
  fields: {
    title: f.text({ required: true }),
    body: f.richText(),
  },
});

// convex/schema.ts
import { defineSchema } from "convex/server";
import { posts } from "./collections/posts";
import { pages } from "./collections/pages";

export default defineSchema({
  posts: posts.table,
  pages: pages.table,
});

import { createVextroCollectionsSchema } from "vextro";

const { tables } = createVextroCollectionsSchema({
  collections: [posts, pages, categories],
});

export default defineSchema({ ...tables });

// convex/admin.ts
import { buildAdminDefinitions } from "vextro/convex/admin";
import { posts } from "./collections/posts";
import { pages } from "./collections/pages";

const collectionDefinitions = buildAdminDefinitions({
  collections: [posts, pages],
});

export const heroSections = defineVextroCollection({
  label: "Hero Sections",
  tableName: "heroSections",
  blockBehavior: true, // opt in with defaults (slug, label from collection)
  fields: {
    heading: f.text({ required: true }),
    subheading: f.textarea(),
    backgroundImage: f.image({ relationTo: "media" }),
  },
});

export const testimonials = defineVextroCollection({
  label: "Testimonials",
  tableName: "testimonials",
  blockBehavior: {
    slug: "testimonial",         // override the block slug
    label: "Testimonial Block",  // override the block label
    picker: { group: "Social Proof", icon: "💬" },
  },
  fields: {
    quote: f.textarea({ required: true }),
    author: f.text({ required: true }),
  },
});

import { hero, cta } from "./blocks";
import { heroSections } from "./collections";

export const pages = defineVextroCollection({
  label: "Pages",
  collectionType: "content",
  tableName: "pages",
  fields: {
    title: f.text({ required: true }),
    content: f.blocks([hero, cta, heroSections]),
  },
});

export const stores = defineVextroCollection({
  // ...
  fields: {
    name: f.text({ required: true }),
    regionScope: f.id("regions", { required: true }),
  },
  scope: {
    field: "regionScope",
    type: "region",
  },
});