@stacksjs/orm 0.72.16 → 0.72.17

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)

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)