@stacksjs/orm 0.72.16 → 0.72.18

package/dist/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/dist/models/EmailSuppression.ts

@@ -0,0 +1,52 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'EmailSuppression',
+  table: 'email_suppressions',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'email_suppressions_email_type_unique',
+      columns: ['email', 'type'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      uri: 'email-suppressions',
+      routes: ['index', 'show', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    email: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required().max(320),
+      },
+    },
+    type: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['bounce', 'complaint', 'unsubscribe', 'manual']),
+      },
+    },
+    reason: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2000),
+      },
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/dist/models/EmailWebhookEvent.ts

@@ -0,0 +1,51 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'EmailWebhookEvent',
+  table: 'email_webhook_events',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'email_webhook_events_provider_event_unique',
+      columns: ['provider', 'event_id'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      uri: 'email-webhook-events',
+      routes: ['index', 'show', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    provider: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['mailgun', 'postmark', 'ses', 'sendgrid']),
+      },
+    },
+    eventId: {
+      required: true,
+      hidden: true,
+      validation: {
+        rule: schema.string().required().max(512),
+      },
+    },
+    processedAt: {
+      required: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+    },
+  },
+
+  dashboard: { enabled: false },
+} as const)

package/dist/models/Error.ts

@@ -0,0 +1,77 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Error',
+  table: 'errors',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'errors_created_at_index',
+      columns: ['created_at'],
+    },
+  ],
+
+  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/dist/models/FailedJob.ts

@@ -0,0 +1,84 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'FailedJob',
+  table: 'failed_jobs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    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(),
+    },
+
+    attempts: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+
+    maxAttempts: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+    },
+
+    durationMs: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+
+    failed_at: {
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: () => '2024-12-23 13:32:19',
+    },
+  },
+} as const)

package/dist/models/Forms/Form.ts

@@ -0,0 +1,91 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A user-defined form: inquiry, permission slip, event registration,
+ * donation. Fields are FormField rows; submissions are FormSubmission rows.
+ *
+ * The `useApi` surface is the ADMIN builder surface. The public render and
+ * submit endpoints live in `@stacksjs/forms` routes, keyed by uuid, and only
+ * ever serve `status: 'active'` forms.
+ */
+export default defineModel({
+  name: 'Form',
+  table: 'forms',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'forms_site_handle_unique',
+      columns: ['site_id', 'handle'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'forms',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+    useSearch: {
+      displayable: ['id', 'name', 'handle', 'status'],
+      searchable: ['name', 'handle'],
+      filterable: ['status'],
+    },
+  },
+
+  belongsTo: ['Site'],
+  hasMany: ['FormField', 'FormSubmission'],
+
+  attributes: {
+    name: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(255),
+      },
+      factory: faker => `${faker.lorem.words(2)} form`,
+    },
+
+    handle: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(64).matches(/^[a-z0-9-]+$/),
+      },
+      factory: faker => faker.lorem.slug(),
+    },
+
+    status: {
+      required: false,
+      order: 3,
+      fillable: true,
+      default: 'draft',
+      validation: {
+        rule: schema.enum(['draft', 'active', 'closed'] as const),
+      },
+      factory: () => 'active',
+    },
+
+    /**
+     * JSON settings: { submitLabel?, confirmation: { type: 'message'|'redirect',
+     * value }, notifyEmails: string[], emailField?, nameField?,
+     * payment?: { mode: 'fixed'|'user_amount'|'field_sum', amountCents?, currency? } }
+     */
+    settings: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+  },
+} as const)

package/dist/models/Forms/FormField.ts

@@ -0,0 +1,127 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One field of a Form. `name` is the machine key submissions store values
+ * under; `conditions` is a show/hide rule set evaluated client-side for UX
+ * and re-evaluated server-side for correctness (a hidden required field is
+ * not required, and values for hidden fields are discarded).
+ */
+export default defineModel({
+  name: 'FormField',
+  table: 'form_fields',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'form_fields_form_name_unique',
+      columns: ['form_id', 'name'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'form-fields',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Form'],
+
+  attributes: {
+    name: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(64).matches(/^[a-z0-9_]+$/),
+      },
+      factory: faker => faker.lorem.word(),
+    },
+
+    label: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(255),
+      },
+      factory: faker => faker.lorem.words(2),
+    },
+
+    type: {
+      required: true,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['text', 'textarea', 'email', 'phone', 'select', 'checkbox', 'radio', 'date', 'file', 'currency', 'section_break'] as const),
+      },
+      factory: faker => faker.helpers.arrayElement(['text', 'email', 'select']),
+    },
+
+    required: {
+      required: false,
+      order: 4,
+      fillable: true,
+      default: false,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean(),
+    },
+
+    position: {
+      required: false,
+      order: 5,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 20 }),
+    },
+
+    width: {
+      required: false,
+      order: 6,
+      fillable: true,
+      default: 'full',
+      validation: {
+        rule: schema.enum(['full', 'half'] as const),
+      },
+      factory: () => 'full',
+    },
+
+    /**
+     * Per-type options JSON: { placeholder?, choices?: {label,value}[],
+     * min?, max?, accept?: string[], maxSizeMb?, amountCents? }
+     */
+    options: {
+      required: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+
+    /**
+     * Visibility rules JSON: { action: 'show'|'hide', logic: 'all'|'any',
+     * rules: [{ field, op, value? }] }
+     */
+    conditions: {
+      required: false,
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => null,
+    },
+  },
+} as const)

package/dist/models/Forms/FormSubmission.ts

@@ -0,0 +1,114 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One submission of a Form. `values` is the validated field map; `email` and
+ * `name` are extracted into typed columns at submit time (from the fields the
+ * form's settings name, defaulting to the first email field) so lookups,
+ * dedupe and confirmation addressing never need JSON extraction SQL.
+ *
+ * No `useApi`: public writes and admin reads both go through the
+ * `@stacksjs/forms` routes, which own spam guards, payment states and
+ * site scoping.
+ */
+export default defineModel({
+  name: 'FormSubmission',
+  table: 'form_submissions',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+  },
+
+  belongsTo: ['Form', 'Site'],
+
+  attributes: {
+    /** Validated { [fieldName]: value } JSON. Named data, not values - values is a SQL keyword. */
+    data: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+
+    email: {
+      required: false,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().max(255),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    name: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    status: {
+      required: false,
+      order: 4,
+      fillable: true,
+      default: 'complete',
+      validation: {
+        rule: schema.enum(['pending_payment', 'complete', 'spam'] as const),
+      },
+      factory: () => 'complete',
+    },
+
+    /** Server-computed. Never trusted from the client. */
+    amountCents: {
+      required: false,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => null,
+    },
+
+    paymentIntentId: {
+      required: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: () => null,
+    },
+
+    ip: {
+      required: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(64),
+      },
+      factory: () => null,
+    },
+
+    submittedAt: {
+      required: false,
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.recent()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+} as const)