@stacksjs/orm 0.72.16 → 0.72.17

package/dist/models/Card.ts

@@ -0,0 +1,118 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * Kanban card (stacksjs/stacks#1846).
+ *
+ * A card belongs to a column (and, via denormalisation, to a board) so
+ * board-wide queries don't need a two-hop join. Cards carry labels +
+ * assignees via pivot tables (`card_labels`, `card_assignees`) — those
+ * relations land in Phase 3 alongside the card-detail modal.
+ *
+ * Hidden from the sidebar as a standalone model row — cards are seen
+ * through `/kanban/[boardId]` (Phase 2), not as a top-level model
+ * viewer. The dashboard's modular config from #1843 carries that
+ * `enabled: false` to both sidebars.
+ */
+export default defineModel({
+  name: 'Card',
+  table: 'cards',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'title', 'columnId', 'boardId', 'position', 'dueDate'],
+      searchable: ['title', 'description'],
+      sortable: ['position', 'createdAt', 'updatedAt', 'dueDate'],
+      filterable: ['boardId', 'columnId', 'archived'],
+    },
+
+    useSeeder: { count: 0 },
+
+    useApi: {
+      uri: 'cards',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  belongsTo: ['BoardColumn', 'Board', 'User'],
+  // Pivot relations land in Phase 3 (labels + assignees).
+  // belongsToMany: {
+  //   labels:    { model: 'Label', table: 'card_labels', foreignKey: 'card_id', relatedKey: 'label_id' },
+  //   assignees: { model: 'User',  table: 'card_assignees', foreignKey: 'card_id', relatedKey: 'user_id' },
+  // },
+
+  attributes: {
+    columnId: {
+      order: 1,
+      fillable: true,
+      validation: { rule: schema.number().required() },
+      factory: () => 1,
+    },
+
+    boardId: {
+      order: 2,
+      fillable: true,
+      // Denormalised from `column.board_id` so a "all cards on board X"
+      // query stays single-table. The kanban API keeps it in sync on
+      // card create/move (Phase 2).
+      validation: { rule: schema.number().required() },
+      factory: () => 1,
+    },
+
+    title: {
+      order: 3,
+      fillable: true,
+      validation: { rule: schema.string().required().min(1).max(300) },
+      factory: faker => faker.lorem.sentence({ min: 3, max: 8 }),
+    },
+
+    description: {
+      order: 4,
+      fillable: true,
+      // Markdown-formatted long description. Rendered in the card detail
+      // modal (Phase 3); the kanban board view shows the first line only.
+      validation: { rule: schema.string().max(10000) },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    position: {
+      order: 5,
+      fillable: true,
+      // Sort order within the parent column. Drag-reorder reflows
+      // adjacent rows in a single transaction (Phase 2). Moving across
+      // columns updates both `columnId` and `position`.
+      validation: { rule: schema.number().min(0) },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    createdByUserId: {
+      order: 6,
+      fillable: true,
+      // The user who created the card. Set server-side from
+      // `request.user.id` on store; surfaced in the card detail.
+      validation: { rule: schema.number() },
+      factory: () => null,
+    },
+
+    dueDate: {
+      order: 7,
+      fillable: true,
+      validation: { rule: schema.string() },
+      factory: () => null,
+    },
+
+    archived: {
+      order: 8,
+      fillable: true,
+      validation: { rule: schema.boolean() },
+      factory: () => false,
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/dist/models/CardComment.ts

@@ -0,0 +1,68 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * Card comment for the dashboard Kanban surface.
+ *
+ * Each comment belongs to a card and (optionally) to the user who
+ * wrote it. Anonymous comments are allowed via nullable `user_id` —
+ * makes the dev dashboard usable on localhost without an auth round-
+ * trip, and supports system-generated activity entries.
+ *
+ * Distinct from `Comment` (which is post-specific) so the schemas
+ * don't fight: post comments carry `author_name`/`author_email` for
+ * public commenters; card comments are internal-only and lean on
+ * the `user_id` FK for attribution.
+ */
+export default defineModel({
+  name: 'CardComment',
+  table: 'card_comments',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'cardId', 'userId', 'body', 'createdAt'],
+      searchable: ['body'],
+      sortable: ['createdAt'],
+      filterable: ['cardId'],
+    },
+
+    useSeeder: { count: 0 },
+
+    useApi: {
+      uri: 'card-comments',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  belongsTo: ['Card', 'User'],
+
+  attributes: {
+    cardId: {
+      order: 1,
+      fillable: true,
+      validation: { rule: schema.number().required() },
+      factory: () => 1,
+    },
+
+    userId: {
+      order: 2,
+      fillable: true,
+      validation: { rule: schema.number() },
+      factory: () => null,
+    },
+
+    body: {
+      order: 3,
+      fillable: true,
+      validation: { rule: schema.string().required().min(1).max(10000) },
+      factory: faker => faker.lorem.sentence(),
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/dist/models/Comment.ts

@@ -0,0 +1,109 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Comment',
+  table: 'comments',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: {
+      count: 25,
+    },
+    useApi: {
+      uri: 'comments',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  belongsTo: ['Post', 'User'],
+
+  attributes: {
+    authorName: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(100),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    authorEmail: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email(),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    content: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(2000),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    body: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2000),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    postTitle: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'approved', 'spam', 'trash']),
+      },
+      factory: faker => faker.helpers.arrayElement(['pending', 'approved', 'spam', 'approved', 'approved']),
+    },
+
+    ipAddress: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(45),
+      },
+      factory: faker => faker.internet.ip(),
+    },
+
+    userAgent: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.internet.userAgent(),
+    },
+
+    isApproved: {
+      required: false,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1 }),
+    },
+  },
+} as const)

package/dist/models/CommunicationSuppression.ts

@@ -0,0 +1,22 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'CommunicationSuppression',
+  table: 'communication_suppressions',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'communication-suppressions', routes: ['index', 'store', 'show', 'destroy'], middleware: ['auth', 'team'] },
+  },
+  indexes: [{ name: 'communication_suppressions_unique', columns: ['team_id', 'channel', 'recipient'], unique: true }],
+  attributes: {
+    recipient: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.internet.email() },
+    channel: { required: true, fillable: true, validation: { rule: schema.enum(['email', 'sms', 'push']) }, factory: () => 'email' },
+    reason: { required: true, fillable: true, validation: { rule: schema.enum(['unsubscribe', 'bounce', 'complaint', 'carrier', 'manual', 'legal']) }, factory: () => 'unsubscribe' },
+    source: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'preference_center' },
+    suppressedAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+    liftedAt: { required: false, fillable: false, validation: { rule: schema.timestamp() }, factory: () => null },
+  },
+} as const)

package/dist/models/ConsentEvent.ts

@@ -0,0 +1,30 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ConsentEvent',
+  table: 'consent_events',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'consent-events', routes: ['index', 'show'], middleware: ['auth', 'team'] },
+  },
+  indexes: [
+    { name: 'consent_events_idempotency_unique', columns: ['team_id', 'idempotency_key'], unique: true },
+    { name: 'consent_events_lookup', columns: ['team_id', 'channel', 'recipient', 'occurred_at'] },
+  ],
+  attributes: {
+    recipient: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.internet.email() },
+    channel: { required: true, fillable: true, validation: { rule: schema.enum(['email', 'sms', 'push']) }, factory: () => 'email' },
+    action: { required: true, fillable: true, validation: { rule: schema.enum(['requested', 'granted', 'revoked', 'confirmed', 'suppressed']) }, factory: () => 'granted' },
+    purpose: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'marketing' },
+    source: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'signup_form' },
+    jurisdiction: { required: false, fillable: true, validation: { rule: schema.string().max(80) }, factory: () => null },
+    policyVersion: { required: true, fillable: true, validation: { rule: schema.string().max(40) }, factory: () => '1.0' },
+    idempotencyKey: { required: false, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.string.uuid() },
+    proof: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({}) },
+    ipAddress: { required: false, fillable: true, validation: { rule: schema.string().max(45) }, factory: faker => faker.internet.ip() },
+    occurredAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+  },
+} as const)

package/dist/models/Content/Author.ts

@@ -0,0 +1,109 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Author', // defaults to the sanitized file name
+  table: 'authors', // defaults to the lowercase, plural name of the model name (or the name of the model file)
+  primaryKey: 'id', // defaults to `id`
+  autoIncrement: true, // defaults to true
+
+  // Define composite indexes
+  indexes: [
+    {
+      name: 'authors_email_name_index',
+      columns: ['email', 'name'],
+    },
+  ],
+
+  traits: {
+    useAuth: {
+      usePasskey: true,
+    },
+    useUuid: true,
+    useTimestamps: true, // defaults to true, `timestampable` used as an alias
+    useSearch: {
+      displayable: ['id', 'name', 'email'], // the fields to become d (defaults to all fields)
+      searchable: ['name', 'email'], // the fields to become searchable (defaults to all fields)
+      sortable: ['created_at', 'updated_at'], // the fields to become sortable (defaults to all fields)
+      filterable: [],
+    },
+
+    // No faker seeding. Blog authorship lives in markdown frontmatter
+    // (content/blog/*.md); this model backs the CMS dashboard only.
+
+    useApi: {
+      // Public catalog: anyone may browse, only authenticated callers may
+      // write. Declared explicitly because the trait now defaults BOTH sides to
+      // `auth` — an undeclared read route is how a customer list leaks
+      // (stacksjs/stacks#2224). Behaviour here is unchanged.
+      middleware: { read: [], write: ['auth'] },
+      uri: 'authors',
+
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['Post'],
+  belongsTo: ['User'],
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(5).max(255),
+        message: {
+          min: 'Name must have a minimum of 3 characters',
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+
+      factory: faker => faker.person.fullName(),
+    },
+
+    email: {
+      unique: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().email(),
+        message: {
+          email: 'Email must be a valid email address',
+        },
+      },
+
+      factory: faker => faker.internet.email(),
+    },
+
+    bio: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+        message: {
+          max: 'Bio must have a maximum of 500 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    avatar: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().url(),
+        message: {
+          url: 'Avatar must be a valid URL',
+        },
+      },
+      factory: faker => faker.image.avatar(),
+    },
+  },
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/Content/Menu.ts

@@ -0,0 +1,56 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A named navigation slot on a site - `main`, `footer`, `portal`. The items
+ * are MenuItem rows; templates fetch the tree by handle
+ * (`fetchMenuTree(siteId, 'main')`) so navigation is content, not code.
+ */
+export default defineModel({
+  name: 'Menu',
+  table: 'menus',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'menus_site_handle_unique',
+      columns: ['site_id', 'handle'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'menus',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Site'],
+  hasMany: ['MenuItem'],
+
+  attributes: {
+    handle: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(64).matches(/^[a-z0-9-]+$/),
+      },
+      factory: faker => faker.helpers.arrayElement(['main', 'footer', 'portal']),
+    },
+
+    name: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(255),
+      },
+      factory: faker => faker.lorem.words(2),
+    },
+  },
+} as const)

package/dist/models/Content/MenuItem.ts

@@ -0,0 +1,91 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One entry in a Menu: either a link to a Page (`pageId`) or a raw `url` -
+ * exactly one of the two. Nests one level via `parentId` for dropdowns.
+ */
+export default defineModel({
+  name: 'MenuItem',
+  table: 'menu_items',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'menu-items',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Menu', 'Page'],
+
+  attributes: {
+    label: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(120),
+      },
+      factory: faker => faker.lorem.words(2),
+    },
+
+    /** External or hand-written link. Null when the item points at a Page. */
+    url: {
+      required: false,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+      },
+      factory: () => null,
+    },
+
+    target: {
+      required: false,
+      order: 3,
+      fillable: true,
+      default: '_self',
+      validation: {
+        rule: schema.enum(['_self', '_blank'] as const),
+      },
+      factory: () => '_self',
+    },
+
+    /** Dropdown parent within the same menu. */
+    parentId: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => null,
+    },
+
+    position: {
+      required: false,
+      order: 5,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+
+    /** `auth` items render only for signed-in visitors (portal links). */
+    visibility: {
+      required: false,
+      order: 6,
+      fillable: true,
+      default: 'public',
+      validation: {
+        rule: schema.enum(['public', 'auth'] as const),
+      },
+      factory: () => 'public',
+    },
+  },
+} as const)