@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/Content/PageRevision.ts

@@ -0,0 +1,86 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A snapshot of a Page's document taken just before an overwrite - restoring
+ * is copying the snapshot back and recording a new revision of what it
+ * replaced. One row per save (the previous state), pruned to the newest N per
+ * page (`config.cms.revisions.keep`).
+ *
+ * No `useApi`: revisions are read and restored through the CMS actions, never
+ * CRUD'd directly.
+ */
+export default defineModel({
+  name: 'PageRevision',
+  table: 'page_revisions',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'page_revisions_page_revision_unique',
+      columns: ['page_id', 'revision'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  belongsTo: ['Page', 'Author'],
+
+  attributes: {
+    /** Monotonic per page, starting at 1. */
+    revision: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    title: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    blocks: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify([]),
+    },
+
+    metaDescription: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(320),
+      },
+      factory: () => null,
+    },
+
+    /** Editor-supplied note ("reworded hero for spring"), optional. */
+    note: {
+      required: false,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: () => null,
+    },
+  },
+} as const)

package/dist/models/Content/Post.ts

@@ -0,0 +1,230 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Post',
+  table: 'posts',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'title', 'slug', 'author', 'views', 'status', 'poster', 'focusKeyword', 'metaDescription', 'canonicalUrl'],
+      // `content`, not `body` - the column is `content`, and the old spelling
+      // silently indexed nothing. `comments` likewise was never a column.
+      searchable: ['title', 'slug', 'author', 'content', 'excerpt', 'focusKeyword', 'metaDescription'],
+      sortable: ['published_at', 'views'],
+      filterable: ['status'],
+    },
+
+    // No faker seeding. The public blog is markdown-based (content/blog/*.md)
+    // rendered by BunPress; this model backs the CMS dashboard only.
+    // `commentable`, not `commentables`: define-model checks the singular key,
+    // so the plural spelling left the trait inert. Now that the commentable
+    // trait targets the real `commentables` table, activating it is correct.
+    commentable: true,
+    useApi: {
+      // Admin surface now: the table carries drafts, and a public read route
+      // is how drafts leak. Public visitors get published posts through the
+      // site's own routes/pages, which filter by status themselves.
+      middleware: ['auth'],
+      uri: 'posts',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Author', 'Site'],
+  belongsToMany: {
+    categories: {
+      model: 'Category',
+      table: 'categorizable_models',
+      foreignKey: 'categorizable_id',
+      relatedKey: 'category_id',
+      pivot: {
+        columns: {
+          categorizable_type: { default: 'posts' },
+        },
+        timestamps: true,
+        uniques: [['category_id', 'categorizable_id', 'categorizable_type']],
+      },
+    },
+    tags: {
+      model: 'Tag',
+      table: 'taggable_models',
+      foreignKey: 'taggable_id',
+      relatedKey: 'tag_id',
+      pivot: {
+        columns: {
+          taggable_type: { default: 'posts' },
+        },
+        timestamps: true,
+        uniques: [['tag_id', 'taggable_id', 'taggable_type']],
+      },
+    },
+  },
+
+  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(),
+    },
+
+    /**
+     * URL identity: `/news/{slug}` beats `/blog/{id}` for a public site.
+     * Nullable for pre-slug rows; the RSS/sitemap actions fall back to id.
+     */
+    slug: {
+      required: false,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.lorem.slug(),
+    },
+    poster: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().url(),
+        message: {
+          url: 'Poster must be a valid URL',
+        },
+      },
+      factory: faker => faker.image.url().substring(0, 255),
+    },
+
+    content: {
+      required: true,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(10).max(100000),
+        message: {
+          min: 'Post body must have a minimum of 10 characters',
+          max: 'Post body must have a maximum of 100000 characters',
+        },
+      },
+      factory: faker => faker.lorem.paragraphs(1),
+    },
+
+    excerpt: {
+      required: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(10).max(500),
+        message: {
+          min: 'Excerpt must have a minimum of 10 characters',
+          max: 'Excerpt must have a maximum of 500 characters',
+        },
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    focusKeyword: {
+      required: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          max: 'Focus keyword must have a maximum of 100 characters',
+        },
+      },
+    },
+
+    metaDescription: {
+      required: false,
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(160),
+        message: {
+          max: 'Meta description must have a maximum of 160 characters',
+        },
+      },
+    },
+
+    canonicalUrl: {
+      required: false,
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().url(),
+        message: {
+          url: 'Canonical URL must be a valid URL',
+        },
+      },
+    },
+
+    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', ' ')
+      },
+    },
+
+    status: {
+      required: true,
+      order: 12,
+      fillable: true,
+      default: 'draft',
+      validation: {
+        rule: schema.enum(['published', 'draft', 'archived']),
+        message: {
+          oneOf: 'Status must be either published, draft, or archived',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['published', 'draft', 'archived']),
+    },
+
+    isFeatured: {
+      required: false,
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'Featured must be a number value',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1 }),
+    },
+  },
+} as const)

package/dist/models/Content/Redirect.ts

@@ -0,0 +1,80 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A path-level redirect on a site. Written automatically when a page's slug
+ * or ancestry changes (`source: 'slug-change'`) so old links keep working,
+ * and manually from the dashboard (`source: 'manual'`). Resolved by the CMS
+ * fallback after page lookup misses.
+ */
+export default defineModel({
+  name: 'Redirect',
+  table: 'redirects',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'redirects_site_from_unique',
+      columns: ['site_id', 'from_path'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'redirects',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Site'],
+
+  attributes: {
+    fromPath: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+      },
+      factory: faker => `/${faker.lorem.slug()}`,
+    },
+
+    toPath: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+      },
+      factory: faker => `/${faker.lorem.slug()}`,
+    },
+
+    statusCode: {
+      required: false,
+      order: 3,
+      fillable: true,
+      default: 301,
+      validation: {
+        // schema.enum is string-typed; the numeric range pins 301/302 (the
+        // read path coerces anything else to 301 anyway).
+        rule: schema.number().min(301).max(302),
+      },
+      factory: () => 301,
+    },
+
+    source: {
+      required: false,
+      order: 4,
+      fillable: true,
+      default: 'manual',
+      validation: {
+        rule: schema.enum(['slug-change', 'manual'] as const),
+      },
+      factory: () => 'manual',
+    },
+  },
+} as const)

package/dist/models/Deployment.ts

@@ -0,0 +1,117 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Deployment',
+  table: 'deployments',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'commitHash', 'branch', 'status', 'duration', 'createdAt'],
+      searchable: ['commitHash', 'branch', 'status', 'author'],
+      sortable: ['createdAt', 'updatedAt', 'duration'],
+      filterable: ['status', 'branch', 'environment'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'deployments',
+      routes: ['index', 'show'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    commitHash: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(7).max(40),
+      },
+      factory: faker => faker.git.commitSha().substring(0, 7),
+    },
+
+    commitMessage: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.git.commitMessage(),
+    },
+
+    branch: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.helpers.arrayElement(['main', 'develop', 'staging', 'feature/auth', 'feature/api', 'fix/hotfix']),
+    },
+
+    status: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['success', 'failed', 'pending', 'running', 'cancelled']),
+    },
+
+    environment: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['production', 'staging', 'development']),
+    },
+
+    duration: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 15, max: 120 }),
+    },
+
+    author: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    url: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.internet.url(),
+    },
+
+    errorLog: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: () => undefined,
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/EmailIdempotency.ts

@@ -0,0 +1,64 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'EmailIdempotency',
+  table: 'email_idempotency',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      uri: 'email-idempotency',
+      routes: ['index', 'show', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    idempotencyKey: {
+      required: true,
+      hidden: true,
+      unique: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+    },
+    messageId: {
+      required: false,
+      validation: {
+        rule: schema.string().max(512),
+      },
+    },
+    recipient: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(2000),
+      },
+    },
+    subject: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(998),
+      },
+    },
+    provider: {
+      required: false,
+      validation: {
+        rule: schema.string().max(100),
+      },
+    },
+    success: {
+      required: true,
+      default: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/dist/models/EmailList.ts

@@ -0,0 +1,134 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'EmailList',
+  table: 'email_lists',
+  primaryKey: 'id',
+  autoIncrement: true,
+  hasMany: ['EmailListSubscriber', 'Campaign', 'CampaignSend'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: {
+      count: 8,
+    },
+    useApi: {
+      uri: 'email-lists',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+    useSearch: {
+      displayable: ['id', 'name', 'slug', 'description', 'status', 'subscriberCount', 'activeCount'],
+      searchable: ['name', 'slug', 'description'],
+      sortable: ['name', 'status', 'subscriberCount', 'createdAt', 'updatedAt'],
+      filterable: ['status', 'isPublic', 'doubleOptIn'],
+    },
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(100),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'Newsletter Subscribers', 'VIP Customers', 'Product Updates',
+        'Beta Testers', 'Blog Subscribers', 'Marketing List',
+        'Enterprise Leads', 'Event Attendees',
+      ]),
+    },
+
+    slug: {
+      unique: true,
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(120),
+      },
+      factory: faker => faker.helpers.slugify(faker.lorem.words(2)).toLowerCase(),
+    },
+
+    description: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    subscriberCount: {
+      required: false,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 25000 }),
+    },
+
+    activeCount: {
+      required: false,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 50, max: 20000 }),
+    },
+
+    unsubscribedCount: {
+      required: false,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 500 }),
+    },
+
+    bouncedCount: {
+      required: false,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'active',
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'archived']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'active', 'active', 'inactive']),
+    },
+
+    isPublic: {
+      required: false,
+      fillable: true,
+      default: 1,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1 }),
+    },
+
+    doubleOptIn: {
+      required: false,
+      fillable: true,
+      default: 1,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: () => 1,
+    },
+  },
+} as const)