@stacksjs/orm 0.72.16 → 0.72.18

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)

package/dist/models/Content/Page.ts

@@ -0,0 +1,205 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A real CMS page: a block document served publicly at `path` on its site.
+ *
+ * `blocks` is the content - an ordered JSON array validated against the block
+ * registry (`@stacksjs/cms` `validateBlocks`). One JSON column rather than
+ * Section/Block rows so a page edit is one atomic write and a revision is a
+ * row copy, not a snapshot-of-a-join.
+ *
+ * The `useApi` surface is the ADMIN surface (auth'd on both sides - the table
+ * now carries draft content, and a public read route is how drafts leak).
+ * Public visitors get pages through the stx servers' CMS fallback, which only
+ * ever serves `status = 'published'` rows for the request's site.
+ */
+export default defineModel({
+  name: 'Page',
+  table: 'pages',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'pages_site_path_unique',
+      columns: ['site_id', 'path'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'title', 'slug', 'path', 'template', 'status', 'views'],
+      searchable: ['title', 'slug', 'path'],
+      sortable: ['views', 'conversions', 'publishedAt'],
+      filterable: ['template', 'status'],
+    },
+    useApi: {
+      middleware: ['auth'],
+      uri: 'pages',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+  },
+
+  belongsTo: ['Author', 'Site'],
+
+  attributes: {
+    title: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(3).max(255),
+        message: {
+          min: 'Title must have a minimum of 3 characters',
+          max: 'Title must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    /** Last path segment, unique among siblings. */
+    slug: {
+      required: false,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.lorem.slug(),
+    },
+
+    /**
+     * Materialized full path (`/admissions/visit`), unique per site. Derived
+     * from the parent chain + slug on save; a slug change rewrites descendant
+     * paths and leaves Redirect rows behind.
+     */
+    path: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+      },
+      factory: faker => `/${faker.lorem.slug()}`,
+    },
+
+    /** Page-tree parent. Null for top-level pages. */
+    parentId: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => null,
+    },
+
+    template: {
+      required: true,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(3),
+        message: {
+          min: 'Template must have a minimum of 3 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['default', 'landing', 'blog', 'contact']),
+    },
+
+    /** The block document. Ordered array of { id, type, props }. */
+    blocks: {
+      required: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify([]),
+    },
+
+    metaDescription: {
+      required: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(320),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    status: {
+      required: false,
+      order: 8,
+      fillable: true,
+      default: 'draft',
+      validation: {
+        rule: schema.enum(['draft', 'published', 'scheduled', 'archived'] as const),
+      },
+      factory: faker => faker.helpers.arrayElement(['draft', 'published']),
+    },
+
+    /** When a `scheduled` page goes live - enforced by the publish job. */
+    scheduledAt: {
+      required: false,
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    views: {
+      required: false,
+      order: 10,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Views count cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1000 }),
+    },
+
+    publishedAt: {
+      required: false,
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'Published timestamp must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.past()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    conversions: {
+      required: false,
+      order: 12,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Conversions count cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+  },
+} as const)