@stacksjs/defaults 0.70.380 → 0.71.2

package/app/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/app/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)

package/app/Models/MagicLinkToken.ts

@@ -0,0 +1,97 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A single-use passwordless sign-in token. `token` stores the SHA-256 of the
+ * raw value - deterministic, so consume is one indexed lookup, and with 256
+ * bits of entropy in the raw token an offline attack on a fast hash is
+ * irrelevant (deliberately NOT the bcrypt-and-scan of password resets).
+ *
+ * No `useApi`: these rows are written and consumed by the auth flow only.
+ */
+export default defineModel({
+  name: 'MagicLinkToken',
+  table: 'magic_link_tokens',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'magic_link_tokens_token_unique',
+      columns: ['token'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  belongsTo: ['User'],
+
+  attributes: {
+    email: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().max(255),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    /** SHA-256 hex of the raw token. Never the raw value. */
+    token: {
+      required: true,
+      order: 2,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(64).max(64),
+      },
+      factory: faker => faker.string.hexadecimal({ length: 64, prefix: '' }).toLowerCase(),
+    },
+
+    expiresAt: {
+      required: true,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => new Date(Date.now() + 15 * 60_000).toISOString().slice(0, 19).replace('T', ' '),
+    },
+
+    consumedAt: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    /** Relative path the consumed link lands on. Validated relative-only. */
+    redirectTo: {
+      required: false,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+      },
+      factory: () => null,
+    },
+
+    /** The site whose primary host the link targets, on multi-site apps. */
+    siteId: {
+      required: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => null,
+    },
+  },
+} as const)

package/app/Models/SenderDomain.ts

@@ -0,0 +1,22 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'SenderDomain',
+  table: 'sender_domains',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'sender-domains', routes: ['index', 'store', 'show', 'update', 'destroy'], middleware: ['auth'] },
+  },
+  indexes: [{ name: 'sender_domains_domain_unique', columns: ['domain'], unique: true }],
+  attributes: {
+    domain: { required: true, fillable: true, validation: { rule: schema.string().max(253) }, factory: faker => faker.internet.domainName() },
+    status: { required: true, fillable: true, default: 'pending', validation: { rule: schema.enum(['pending', 'verified', 'failed', 'disabled']) }, factory: () => 'pending' },
+    selector: { required: true, fillable: true, default: 'mail', validation: { rule: schema.string().max(63) }, factory: () => 'mail' },
+    dnsRecords: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify([]) },
+    verifiedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+    lastCheckedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+  },
+} as const)

package/app/Models/Site.ts

@@ -0,0 +1,112 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A public web property served by this app: one host (subdomain of
+ * `config.sites.baseDomain`, plus any verified custom domains via
+ * SiteDomain), one content tree, one theme. A team may own several - a main
+ * site, a microsite, a campaign landing page - each with its own domain.
+ *
+ * The `useApi` surface is the ADMIN surface (auth'd, team-scoped). Public
+ * visitors never read sites through it; the serving layer resolves the site
+ * from the Host header (`@stacksjs/sites`).
+ */
+export default defineModel({
+  name: 'Site',
+  table: 'sites',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    observe: true, // site:updated clears the host-resolution cache
+
+    useSeeder: {
+      count: 2,
+    },
+
+    useApi: {
+      uri: 'sites',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+
+    useSearch: {
+      displayable: ['id', 'name', 'subdomain', 'status'],
+      searchable: ['name', 'subdomain'],
+      sortable: ['name', 'createdAt'],
+      filterable: ['status'],
+    },
+  },
+
+  belongsTo: ['Team'],
+  hasMany: ['SiteDomain'],
+
+  attributes: {
+    name: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(255),
+        message: {
+          min: 'Site name must have a minimum of 2 characters',
+          max: 'Site name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => `${faker.company.name()} School`,
+    },
+
+    subdomain: {
+      required: true,
+      order: 2,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(2).max(63).matches(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/),
+        message: {
+          matches: 'Subdomain may only contain lowercase letters, numbers and hyphens',
+        },
+      },
+      factory: faker => faker.internet.domainWord(),
+    },
+
+    status: {
+      required: true,
+      order: 3,
+      fillable: true,
+      default: 'active',
+      validation: {
+        rule: schema.enum(['active', 'suspended', 'archived'] as const),
+      },
+      factory: () => 'active',
+    },
+
+    /** Theme tokens, locale, analytics id - render-time knobs, JSON. */
+    settings: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+
+    timezone: {
+      required: false,
+      order: 5,
+      fillable: true,
+      default: 'America/New_York',
+      validation: {
+        rule: schema.string().max(64),
+      },
+      factory: () => 'America/New_York',
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+})

package/app/Models/SiteDomain.ts

@@ -0,0 +1,74 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A custom domain routed to a Site. Only rows with `verifiedAt` set resolve
+ * traffic - verification proves the school controls the DNS before we serve
+ * their content on it. `isPrimary` names the canonical host: sessions are
+ * host-scoped cookies, so every other host 301s there and portal logins
+ * always land on one origin.
+ */
+export default defineModel({
+  name: 'SiteDomain',
+  table: 'site_domains',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    observe: true, // domain changes clear the host-resolution cache
+
+    useApi: {
+      uri: 'site-domains',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  belongsTo: ['Site'],
+
+  attributes: {
+    domain: {
+      required: true,
+      order: 1,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(4).max(253),
+      },
+      factory: faker => faker.internet.domainName(),
+    },
+
+    isPrimary: {
+      required: false,
+      order: 2,
+      fillable: true,
+      default: false,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => false,
+    },
+
+    verifiedAt: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    sslStatus: {
+      required: false,
+      order: 4,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'issued', 'failed'] as const),
+      },
+      factory: () => 'pending',
+    },
+  },
+})

package/app/Models/SmsOptOut.ts

@@ -0,0 +1,65 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A phone number that texted STOP. Keyed by NUMBER, not user - the reply
+ * comes from a handset, and whoever holds it has spoken for it. Checked by
+ * `notify()`'s sms channel on every non-emergency send; written and cleared
+ * by `handleInboundSms()` (`@stacksjs/sms`).
+ */
+export default defineModel({
+  name: 'SmsOptOut',
+  table: 'sms_opt_outs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'sms_opt_outs_phone_unique',
+      columns: ['phone'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  attributes: {
+    /** E.164 where derivable (`+13105550199`). */
+    phone: {
+      required: true,
+      order: 1,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(7).max(20),
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    reason: {
+      required: false,
+      order: 2,
+      fillable: true,
+      default: 'stop-keyword',
+      validation: {
+        rule: schema.string().max(64),
+      },
+      factory: () => 'stop-keyword',
+    },
+
+    optedOutAt: {
+      required: true,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.recent()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+} as const)

package/app/Models/UsageEvent.ts

@@ -0,0 +1,24 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'UsageEvent',
+  table: 'usage_events',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'usage-events', routes: ['index', 'show'], middleware: ['auth'] },
+  },
+  indexes: [
+    { name: 'usage_events_idempotency_unique', columns: ['idempotency_key'], unique: true },
+    { name: 'usage_events_meter_period', columns: ['team_id', 'meter', 'occurred_at'] },
+  ],
+  attributes: {
+    meter: { required: true, fillable: true, validation: { rule: schema.enum(['contacts', 'email_sends', 'sms_segments', 'ai_generations', 'storage_bytes']) }, factory: () => 'email_sends' },
+    quantity: { required: true, fillable: true, default: 1, validation: { rule: schema.number().min(0) }, factory: () => 1 },
+    idempotencyKey: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.string.uuid() },
+    metadata: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({}) },
+    occurredAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+  },
+} as const)