@stacksjs/defaults 0.70.57 → 0.70.59

package/app/Models/EmailList.ts

@@ -0,0 +1,126 @@
+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'],
+    },
+  },
+
+  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)

package/app/Models/EmailListSubscriber.ts

@@ -0,0 +1,91 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * Pivot row between Subscriber and EmailList.
+ *
+ * One subscriber can be on many lists; the subscribers.email unique
+ * constraint stays intact because membership lives here. Each pivot
+ * row carries its own UUID, which doubles as the per-list unsubscribe
+ * token — that lets a recipient drop "Weekly Digest" via one link
+ * without dropping every other list (or transactional mail).
+ */
+export default defineModel({
+  name: 'EmailListSubscriber',
+  table: 'email_list_subscribers',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['EmailList', 'Subscriber'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: {
+      uri: 'email-list-subscribers',
+      routes: ['index', 'show'],
+      // The pivot leaks list-membership PII (which addresses are on
+      // which list, signup source, status). Auth-gate it. Public
+      // unsubscribe goes through the dedicated token route, not this
+      // CRUD surface.
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    emailListId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 8 }),
+    },
+
+    subscriberId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'subscribed',
+      validation: {
+        rule: schema.enum(['subscribed', 'unsubscribed', 'pending', 'bounced']),
+      },
+      factory: faker => faker.helpers.arrayElement(['subscribed', 'subscribed', 'subscribed', 'unsubscribed']),
+    },
+
+    source: {
+      required: false,
+      fillable: true,
+      default: 'api',
+      validation: {
+        rule: schema.string().max(100),
+      },
+      factory: faker => faker.helpers.arrayElement(['homepage', 'blog', 'landing-page', 'api', 'import']),
+    },
+
+    subscribedAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: faker => faker.date.recent({ days: 90 }).toISOString().slice(0, 19).replace('T', ' '),
+    },
+
+    unsubscribedAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+  },
+} as const)

package/app/Models/Error.ts

@@ -0,0 +1,70 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Error',
+  table: 'errors',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  attributes: {
+    type: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'type must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.system.fileType(),
+    },
+
+    message: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+        message: {
+          string: 'message must be a string',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    stack: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'stack must be a text',
+        },
+      },
+      factory: faker => faker.system.filePath(),
+    },
+
+    status: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          string: 'status must be a number',
+        },
+      },
+      factory: faker => faker.number.int({ min: 400, max: 500 }),
+    },
+
+    additional_info: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'additional_info must be a text',
+        },
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+  },
+} as const)

package/app/Models/FailedJob.ts

@@ -0,0 +1,62 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'FailedJob',
+  table: 'failed_jobs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  attributes: {
+    connection: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Connection must have a maximum of 100 characters',
+          string: 'Connection must be a string',
+        },
+      },
+      factory: () => 'default',
+    },
+
+    queue: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Queue must have a maximum of 255 characters',
+        },
+      },
+      factory: () => 'default',
+    },
+
+    payload: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    exception: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    failed_at: {
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: () => '2024-12-23 13:32:19',
+    },
+  },
+} as const)

package/app/Models/Job.ts

@@ -0,0 +1,63 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Job',
+  table: 'jobs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    useSeeder: {
+      count: 15,
+    },
+  },
+
+  attributes: {
+    queue: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Queue must have a maximum of 255 characters',
+        },
+      },
+      factory: () => 'default',
+    },
+
+    payload: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    attempts: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'attempts must be a number',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 10 }),
+    },
+
+    available_at: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 1000000, max: 1999999 }),
+    },
+    reserved_at: {
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: () => '2024-12-23 13:32:19',
+    },
+  },
+} as const)

package/app/Models/Label.ts

@@ -0,0 +1,66 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * Card label / tag (stacksjs/stacks#1846).
+ *
+ * Labels are board-scoped: each board owns its own label palette
+ * (so "Bug" on board A is a different record from "Bug" on board B,
+ * with potentially different colours). Cards attach labels via the
+ * `card_labels` pivot — that wiring lands in Phase 3.
+ *
+ * Hidden from the sidebar as a standalone model row — labels are
+ * managed inside the board view, not as a top-level surface.
+ */
+export default defineModel({
+  name: 'Label',
+  table: 'labels',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'color', 'boardId'],
+      searchable: ['name'],
+      sortable: ['name', 'createdAt'],
+      filterable: ['boardId'],
+    },
+
+    useSeeder: { count: 0 },
+
+    useApi: {
+      uri: 'labels',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Board'],
+
+  attributes: {
+    boardId: {
+      order: 1,
+      fillable: true,
+      validation: { rule: schema.number().required() },
+      factory: () => 1,
+    },
+
+    name: {
+      order: 2,
+      fillable: true,
+      validation: { rule: schema.string().required().min(1).max(60) },
+      factory: faker => faker.helpers.arrayElement(['Bug', 'Feature', 'Docs', 'Refactor', 'Urgent']),
+    },
+
+    color: {
+      order: 3,
+      fillable: true,
+      // Hue token resolved by the UI — same palette as Board.color.
+      validation: { rule: schema.string().max(40) },
+      factory: faker => faker.helpers.arrayElement(['red', 'amber', 'emerald', 'blue', 'violet', 'slate']),
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/app/Models/Log.ts

@@ -0,0 +1,110 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Log',
+  table: 'logs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    useSeeder: {
+      count: 50,
+    },
+    useSearch: {
+      displayable: ['id', 'type', 'source', 'message', 'project', 'timestamp'],
+      searchable: ['message', 'project', 'file'],
+      sortable: ['timestamp', 'type', 'source'],
+      filterable: ['type', 'source', 'project'],
+    },
+  },
+
+  attributes: {
+    timestamp: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+        message: {
+          date: 'Timestamp must be a valid date',
+        },
+      },
+      factory: faker => faker.date.recent().getTime(),
+    },
+
+    type: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['warning', 'error', 'info', 'success']).required(),
+        message: {
+          enum: 'Type must be one of: warning, error, info, success',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['warning', 'error', 'info', 'success']),
+    },
+
+    source: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['file', 'cli', 'system']).required(),
+        message: {
+          enum: 'Source must be one of: file, cli, system',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['file', 'cli', 'system']),
+    },
+
+    message: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(1).max(1000),
+        message: {
+          min: 'Message must not be empty',
+          max: 'Message must not exceed 1000 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    project: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).required().max(255),
+        message: {
+          min: 'Project name must not be empty',
+          max: 'Project name must not exceed 255 characters',
+        },
+      },
+      factory: faker => faker.company.name(),
+    },
+
+    stacktrace: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(5000),
+        message: {
+          max: 'Stacktrace must not exceed 5000 characters',
+        },
+      },
+      factory: faker => faker.lorem.paragraphs(2),
+    },
+
+    file: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'File path must not exceed 255 characters',
+        },
+      },
+      factory: faker => faker.system.filePath().substring(0, 255),
+    },
+  },
+} as const)

package/app/Models/Notification.ts

@@ -0,0 +1,118 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Notification',
+  table: 'notifications',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: {
+      count: 30,
+    },
+    useApi: {
+      uri: 'notifications',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['User'],
+
+  attributes: {
+    type: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['email', 'sms', 'push', 'slack', 'webhook']),
+      },
+      factory: faker => faker.helpers.arrayElement(['email', 'sms', 'push', 'slack', 'webhook']),
+    },
+
+    channel: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(50),
+      },
+      factory: faker => faker.helpers.arrayElement(['mail', 'database', 'broadcast', 'slack']),
+    },
+
+    recipient: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    subject: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'Welcome!', 'Order Shipped', 'New Message', 'Daily Report',
+        'Payment Received', 'Account Updated', 'Security Alert',
+        'New Comment', 'Subscription Renewed', 'Password Reset',
+      ]),
+    },
+
+    body: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(5000),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'sent', 'delivered', 'failed', 'read']),
+      },
+      factory: faker => faker.helpers.arrayElement(['sent', 'delivered', 'delivered', 'failed', 'read']),
+    },
+
+    readAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        if (faker.datatype.boolean()) {
+          return faker.date.recent().toISOString().slice(0, 19).replace('T', ' ')
+        }
+        return null
+      },
+    },
+
+    sentAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        return faker.date.recent().toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    metadata: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: () => JSON.stringify({ source: 'system' }),
+    },
+  },
+} as const)