Relations

Link to one recordCopy Anchor Link

Point an article at a category with field.relation. target is a function, so two content types can refer to each other without an import cycle:

import { categoryContentType } from "./category";

fields: {
  category: field.relation({ 
    required: true,
    onDelete: "restrict",
    target: () => categoryContentType,
  }),
},

Then tell createContentModel which column the foreign key references:

import { example_categories } from "./categories";

export const articleContent = createContentModel(articleContentType, {
  references: { category: () => example_categories.id }, 
});

references needs one entry per relation field. A missing or extra key is a type error. field.user(), field.file() and self: true relations find their table on their own and need no entry.

Link to many recordsCopy Anchor Link

Add multiple: true. The advanced article has two to-many relations: a set of categories and an ordered "read next" list that points back at articles:

fields: {
  categories: field.relation({
    multiple: true,
    onDelete: "restrict",
    target: () => categoryContentType,
  }),
  relatedArticles: field.relation({
    multiple: true,
    onDelete: "cascade",
    ordered: true,
    self: true,
  }),
},

ordered: true keeps the order editors arrange. Without it, the set is stored in ascending id order. onDelete: "cascade" on a to-many relation drops the link when the target is deleted, and "restrict" refuses the delete. A to-many relation cannot be required or nullable; use min: 1 to demand at least one target.

Each to-many field gets a junction table with itemId, relatedItemId, position and createdAt. Give categories its reference and export both junction tables, or Drizzle Kit leaves them out of the migration:

export const advancedArticleContent = createContentModel(
  advancedArticleContentType,
  { references: { categories: () => example_categories.id } },
);

export const example_advanced_articles = advancedArticleContent.table;
export const example_advanced_articles_categories =
  advancedArticleContent.advancedTables.junctions.categories;
export const example_advanced_articles_related_articles =
  advancedArticleContent.advancedTables.junctions.relatedArticles;

Group related fieldsCopy Anchor Link

field.group keeps fields that belong together under one key:

syndication: field.group({
  fields: {
    indexable: field.boolean({ defaultValue: true }),
    noIndex: field.boolean({ defaultValue: false }),
    priority: field.number({ integer: true, min: 0, max: 10, defaultValue: 5 }),
  },
}),

A group adds one column per leaf to the main table: syndicationIndexable, syndicationNoIndex and syndicationPriority. The API reads and writes it as { syndication: { indexable, noIndex, priority } }, and other options refer to a leaf by path, such as indexes: [{ on: ["syndication.priority"] }]. Leaves can be text, textarea, number, boolean, enum or dateTime fields. An optional group needs leaves that are nullable or have a default.

Add repeatable rowsCopy Anchor Link

field.repeatable stores an ordered list of small rows, such as FAQ entries:

faq: field.repeatable({
  max: 20,
  fields: {
    question: field.text({ required: true, minLength: 3, maxLength: 200 }),
    answer: field.textarea({ required: true }),
  },
}),

The rows go to a child table, example_advanced_articles_faq, with id, itemId, position, createdAt, updatedAt and one column per leaf. Deleting the article deletes its rows. Export the child table too:

export const example_advanced_articles_faq =
  advancedArticleContent.advancedTables.repeatables.faq;

Build and migrateCopy Anchor Link

bun run build:plugins && bun run db:migrate

The generated migration creates one table per junction and repeatable field.