@stacksjs/defaults 0.70.380 → 0.71.2

package/app/Actions/Auth/MagicLinkConsumeAction.ts

@@ -0,0 +1,53 @@
+import { Action } from '@stacksjs/actions'
+import { Auth, authCookie, consumeMagicLink } from '@stacksjs/auth'
+import { config } from '@stacksjs/config'
+import { response } from '@stacksjs/router'
+import { schema } from '@stacksjs/validation'
+
+export default new Action({
+  name: 'MagicLinkConsumeAction',
+  description: 'Consume a magic link and sign the user in',
+  method: 'POST',
+
+  validations: {
+    token: {
+      rule: schema.string().min(16).max(255),
+      message: 'Token is required.',
+    },
+  },
+
+  async handle(request: RequestInstance) {
+    if (!config.auth.magicLink?.enabled)
+      return response.notFound('Magic-link sign-in is not enabled')
+
+    const consumed = await consumeMagicLink(String(request.get('token')))
+    if (!consumed.ok) {
+      const messages: Record<string, string> = {
+        invalid: 'That sign-in link is not valid.',
+        expired: 'That sign-in link has expired. Request a new one.',
+        used: 'That sign-in link was already used. Request a new one.',
+        'no-user': 'That sign-in link is not valid.',
+      }
+      return response.unauthorized(messages[consumed.reason] ?? 'That sign-in link is not valid.')
+    }
+
+    // The same token pack + httpOnly cookie a password login issues, so
+    // stxPageAuthMiddleware-gated pages treat passwordless users identically.
+    const result = await Auth.loginUsingId(consumed.userId)
+    if (!result)
+      return response.unauthorized('That sign-in link is not valid.')
+
+    return response.json({
+      access_token: result.token,
+      refresh_token: result.refreshToken,
+      token_type: 'Bearer',
+      expires_in: result.expiresIn,
+      redirect_to: consumed.redirectTo,
+      user: {
+        id: result.user?.id,
+        email: result.user?.email,
+        name: result.user?.name,
+      },
+    }, { headers: { 'Set-Cookie': authCookie(result.token) } })
+  },
+})

package/app/Actions/Auth/MagicLinkSendAction.ts

@@ -0,0 +1,35 @@
+import { Action } from '@stacksjs/actions'
+import { sendMagicLink } from '@stacksjs/auth'
+import { config } from '@stacksjs/config'
+import { response } from '@stacksjs/router'
+import { schema } from '@stacksjs/validation'
+
+export default new Action({
+  name: 'MagicLinkSendAction',
+  description: 'Email a passwordless sign-in link',
+  method: 'POST',
+
+  validations: {
+    email: {
+      rule: schema.string().email(),
+      message: 'Email must be a valid email address.',
+    },
+  },
+
+  async handle(request: RequestInstance) {
+    if (!config.auth.magicLink?.enabled)
+      return response.notFound('Magic-link sign-in is not enabled')
+
+    const email = request.get('email')
+    const redirectTo = request.get('redirect_to') as string | undefined
+
+    // Fire-and-return uniform: sendMagicLink is a silent no-op for unknown
+    // emails and self-rate-limits per address, so the response never says
+    // whether the account exists.
+    await sendMagicLink(String(email), { redirectTo })
+
+    return response.json({
+      message: 'If an account exists for that address, a sign-in link is on its way.',
+    }, { status: 202 })
+  },
+})

package/app/Actions/Cms/SitemapAction.ts

@@ -1,6 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { config } from '@stacksjs/config'
-import { Category, Post } from '@stacksjs/orm'
+import { Category, Page, Post } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
 
 export default new Action({
@@ -10,6 +10,7 @@ export default new Action({
   async handle() {
     const allPosts = await Post.where('status', '=', 'published').get()
     const allCategories = await Category.all()
+    const allPages = await Page.where('status', '=', 'published').get()
     const siteUrl = config.app.url || 'https://example.com'
 
     const postUrls = allPosts
@@ -18,9 +19,10 @@ export default new Action({
           ? new Date(post.updated_at).toISOString().split('T')[0]
           : new Date().toISOString().split('T')[0]
 
+        // Slug-first now that posts carry one; id keeps pre-slug rows reachable.
         return `
   <url>
-    <loc>${siteUrl}/blog/${post.id}</loc>
+    <loc>${siteUrl}/blog/${post.slug || post.id}</loc>
     <lastmod>${lastmod}</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.8</priority>
@@ -28,6 +30,24 @@ export default new Action({
       })
       .join('\n')
 
+    // CMS pages: published block documents served at their materialized path.
+    const pageUrls = allPages
+      .filter(page => page.path && page.path !== '/')
+      .map((page) => {
+        const lastmod = page.updated_at
+          ? new Date(page.updated_at).toISOString().split('T')[0]
+          : new Date().toISOString().split('T')[0]
+
+        return `
+  <url>
+    <loc>${siteUrl}${page.path}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.7</priority>
+  </url>`
+      })
+      .join('\n')
+
     const categoryUrls = allCategories
       .map((category) => {
         return `
@@ -53,6 +73,7 @@ export default new Action({
   </url>
 ${postUrls}
 ${categoryUrls}
+${pageUrls}
 </urlset>`
 
     return response.xml(sitemap)

package/app/Jobs/PublishScheduledPagesJob.ts

@@ -0,0 +1,26 @@
+import { publishDuePages } from '@stacksjs/cms'
+import { log } from '@stacksjs/logging'
+import { Job } from '@stacksjs/queue'
+
+/**
+ * Flip due `scheduled` CMS pages to `published`.
+ *
+ * `status: 'scheduled'` + `scheduled_at` is a promise the editor made; this
+ * job is what keeps it. Every minute, cheap when nothing is due (one indexed
+ * SELECT). Runs via the standard scheduler registration - add it to
+ * `app/Scheduler.ts` (`schedule.job('PublishScheduledPages').everyMinute()`),
+ * or rely on an app's own registration conventions.
+ */
+export default new Job({
+  name: 'PublishScheduledPages',
+  description: 'Publish CMS pages whose scheduled time has arrived',
+  queue: 'default',
+  tries: 2,
+  backoff: [30],
+
+  async handle() {
+    const published = await publishDuePages()
+    if (published > 0)
+      log.info(`[cms] published ${published} scheduled page${published === 1 ? '' : 's'}`)
+  },
+})

package/app/Middleware/Site.ts

@@ -0,0 +1,14 @@
+import { siteResolver } from '@stacksjs/sites'
+
+/**
+ * Site Middleware
+ *
+ * Resolves the request's site from its Host header (`@stacksjs/sites`) and
+ * publishes it as `request.site` plus the ambient `currentSite()` context.
+ * A no-op while `config/sites.ts` is disabled. With `sites.strict`, an
+ * unknown host answers 404 here.
+ *
+ * Usage:
+ * route.group({ middleware: ['site'] }, () => { ... public tenant routes ... })
+ */
+export default siteResolver

package/app/Middleware.ts

@@ -14,6 +14,7 @@ export default {
   'guest': 'Guest',
   'api': 'Api',
   'team': 'Team',
+  'site': 'Site',
   'logger': 'Logger',
   'abilities': 'Abilities',
   'can': 'Can',

package/app/Models/Automation.ts

@@ -0,0 +1,23 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Automation',
+  table: 'automations',
+  belongsTo: ['Team'],
+  hasMany: ['AutomationRun'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'automations', routes: ['index', 'store', 'show', 'update', 'destroy'], middleware: ['auth'] },
+    observe: true,
+  },
+  attributes: {
+    name: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.lorem.words(3) },
+    status: { required: true, fillable: true, default: 'draft', validation: { rule: schema.enum(['draft', 'active', 'paused', 'archived']) }, factory: () => 'draft' },
+    version: { required: true, fillable: true, default: 1, validation: { rule: schema.number().min(1) }, factory: () => 1 },
+    trigger: { required: true, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({ type: 'subscriber_joined' }) },
+    graph: { required: true, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({ nodes: [], edges: [] }) },
+    publishedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+  },
+} as const)

package/app/Models/AutomationRun.ts

@@ -0,0 +1,26 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'AutomationRun',
+  table: 'automation_runs',
+  belongsTo: ['Team', 'Automation'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'automation-runs', routes: ['index', 'show'], middleware: ['auth'] },
+  },
+  indexes: [{ name: 'automation_runs_idempotency_unique', columns: ['idempotency_key'], unique: true }],
+  attributes: {
+    status: { required: true, fillable: true, default: 'queued', validation: { rule: schema.enum(['queued', 'running', 'waiting', 'completed', 'failed', 'cancelled']) }, factory: () => 'queued' },
+    currentNodeId: { required: false, fillable: true, validation: { rule: schema.string().max(100) }, factory: () => null },
+    version: { required: true, fillable: true, default: 1, validation: { rule: schema.number().min(1) }, factory: () => 1 },
+    subjectType: { required: false, fillable: true, validation: { rule: schema.string().max(80) }, factory: () => 'contact' },
+    subjectId: { required: false, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => null },
+    context: { required: true, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({}) },
+    idempotencyKey: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.string.uuid() },
+    startedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+    finishedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+    error: { required: false, fillable: true, validation: { rule: schema.string() }, factory: () => null },
+  },
+} as const)

package/app/Models/Campaign.ts

@@ -6,8 +6,8 @@ export default defineModel({
   table: 'campaigns',
   primaryKey: 'id',
   autoIncrement: true,
-  belongsTo: ['EmailList'],
-  hasMany: ['CampaignSend'],
+  belongsTo: ['Team', 'EmailList'],
+  hasMany: ['CampaignSend', 'CampaignVariant'],
 
   traits: {
     useUuid: true,
@@ -24,7 +24,7 @@ export default defineModel({
       displayable: ['id', 'name', 'type', 'status', 'subject', 'scheduledAt', 'sentAt'],
       searchable: ['name', 'description', 'subject'],
       sortable: ['name', 'type', 'status', 'scheduledAt', 'sentAt', 'createdAt', 'updatedAt'],
-      filterable: ['type', 'status', 'emailListId', 'currency'],
+      filterable: ['teamId', 'type', 'status', 'emailListId', 'currency'],
     },
     observe: true,
   },
@@ -109,6 +109,33 @@ export default defineModel({
       factory: faker => faker.lorem.paragraphs(2),
     },
 
+    content: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify([]),
+    },
+
+    channelSettings: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+
+    segmentDefinition: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({ operator: 'and', rules: [] }),
+    },
+
     fromName: {
       required: false,
       fillable: true,
@@ -127,6 +154,43 @@ export default defineModel({
       factory: faker => faker.internet.email(),
     },
 
+    replyTo: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().max(255),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    timezone: {
+      required: true,
+      fillable: true,
+      default: 'UTC',
+      validation: {
+        rule: schema.string().max(100),
+      },
+      factory: () => 'UTC',
+    },
+
+    recurrence: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: () => null,
+    },
+
+    experimentMetric: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['open_rate', 'click_rate', 'conversion_rate']),
+      },
+      factory: () => null,
+    },
+
     emailListId: {
       required: false,
       fillable: true,

package/app/Models/CampaignSend.ts

@@ -6,7 +6,15 @@ export default defineModel({
   table: 'campaign_sends',
   primaryKey: 'id',
   autoIncrement: true,
-  belongsTo: ['Campaign', 'Subscriber', 'EmailList'],
+  belongsTo: ['Team', 'Campaign', 'Subscriber', 'EmailList', 'CampaignVariant'],
+
+  indexes: [
+    {
+      name: 'campaign_sends_idempotency_unique',
+      columns: ['idempotency_key'],
+      unique: true,
+    },
+  ],
 
   traits: {
     useUuid: true,
@@ -32,21 +40,21 @@ export default defineModel({
     },
 
     subscriberId: {
-      required: true,
+      required: false,
       fillable: true,
       validation: {
         rule: schema.number(),
       },
-      factory: faker => faker.number.int({ min: 1, max: 100 }),
+      factory: () => null,
     },
 
     emailListId: {
-      required: true,
+      required: false,
       fillable: true,
       validation: {
         rule: schema.number(),
       },
-      factory: faker => faker.number.int({ min: 1, max: 8 }),
+      factory: () => null,
     },
 
     status: {
@@ -54,11 +62,42 @@ export default defineModel({
       fillable: true,
       default: 'queued',
       validation: {
-        rule: schema.enum(['queued', 'sent', 'failed', 'bounced', 'complained']),
+        rule: schema.enum([
+          'queued', 'deferred', 'sending', 'sent', 'delivered', 'failed',
+          'undelivered', 'bounced', 'complained', 'suppressed', 'cancelled',
+        ]),
       },
       factory: faker => faker.helpers.arrayElement(['sent', 'sent', 'sent', 'queued', 'failed', 'bounced']),
     },
 
+    channel: {
+      required: true,
+      fillable: true,
+      default: 'email',
+      validation: {
+        rule: schema.enum(['email', 'sms', 'push']),
+      },
+      factory: faker => faker.helpers.arrayElement(['email', 'sms']),
+    },
+
+    recipient: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    idempotencyKey: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
     providerMessageId: {
       required: false,
       fillable: true,
@@ -103,5 +142,50 @@ export default defineModel({
       },
       factory: () => null,
     },
+
+    deliveredAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    failedAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    segments: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => 1,
+    },
+
+    cost: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => 0,
+    },
+
+    metadata: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
   },
 } as const)

package/app/Models/CampaignVariant.ts

@@ -0,0 +1,25 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'CampaignVariant',
+  table: 'campaign_variants',
+  belongsTo: ['Team', 'Campaign'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'campaign-variants', routes: ['index', 'store', 'show', 'update', 'destroy'], middleware: ['auth'] },
+  },
+  indexes: [{ name: 'campaign_variants_name_unique', columns: ['campaign_id', 'name'], unique: true }],
+  attributes: {
+    name: { required: true, fillable: true, validation: { rule: schema.string().max(80) }, factory: faker => faker.helpers.arrayElement(['Control', 'Variant B']) },
+    subject: { required: false, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.lorem.sentence(6) },
+    content: { required: true, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify([]) },
+    allocation: { required: true, fillable: true, default: 50, validation: { rule: schema.number().min(0).max(100) }, factory: () => 50 },
+    sentCount: { required: true, fillable: true, default: 0, validation: { rule: schema.number().min(0) }, factory: () => 0 },
+    openCount: { required: true, fillable: true, default: 0, validation: { rule: schema.number().min(0) }, factory: () => 0 },
+    clickCount: { required: true, fillable: true, default: 0, validation: { rule: schema.number().min(0) }, factory: () => 0 },
+    conversionCount: { required: true, fillable: true, default: 0, validation: { rule: schema.number().min(0) }, factory: () => 0 },
+    isWinner: { required: true, fillable: true, default: false, validation: { rule: schema.boolean() }, factory: () => false },
+  },
+} as const)

package/app/Models/CommunicationSuppression.ts

@@ -0,0 +1,22 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'CommunicationSuppression',
+  table: 'communication_suppressions',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'communication-suppressions', routes: ['index', 'store', 'show', 'destroy'], middleware: ['auth'] },
+  },
+  indexes: [{ name: 'communication_suppressions_unique', columns: ['team_id', 'channel', 'recipient'], unique: true }],
+  attributes: {
+    recipient: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.internet.email() },
+    channel: { required: true, fillable: true, validation: { rule: schema.enum(['email', 'sms', 'push']) }, factory: () => 'email' },
+    reason: { required: true, fillable: true, validation: { rule: schema.enum(['unsubscribe', 'bounce', 'complaint', 'carrier', 'manual', 'legal']) }, factory: () => 'unsubscribe' },
+    source: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'preference_center' },
+    suppressedAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+    liftedAt: { required: false, fillable: false, validation: { rule: schema.timestamp() }, factory: () => null },
+  },
+} as const)

package/app/Models/ConsentEvent.ts

@@ -0,0 +1,26 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ConsentEvent',
+  table: 'consent_events',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'consent-events', routes: ['index', 'show'], middleware: ['auth'] },
+  },
+  indexes: [{ name: 'consent_events_lookup', columns: ['team_id', 'channel', 'recipient', 'occurred_at'] }],
+  attributes: {
+    recipient: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.internet.email() },
+    channel: { required: true, fillable: true, validation: { rule: schema.enum(['email', 'sms', 'push']) }, factory: () => 'email' },
+    action: { required: true, fillable: true, validation: { rule: schema.enum(['requested', 'granted', 'revoked', 'confirmed', 'suppressed']) }, factory: () => 'granted' },
+    purpose: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'marketing' },
+    source: { required: true, fillable: true, validation: { rule: schema.string().max(120) }, factory: () => 'signup_form' },
+    jurisdiction: { required: false, fillable: true, validation: { rule: schema.string().max(80) }, factory: () => null },
+    policyVersion: { required: true, fillable: true, validation: { rule: schema.string().max(40) }, factory: () => '1.0' },
+    proof: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({}) },
+    ipAddress: { required: false, fillable: true, validation: { rule: schema.string().max(45) }, factory: faker => faker.internet.ip() },
+    occurredAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+  },
+} as const)

package/app/Models/Content/Menu.ts

@@ -0,0 +1,56 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A named navigation slot on a site - `main`, `footer`, `portal`. The items
+ * are MenuItem rows; templates fetch the tree by handle
+ * (`fetchMenuTree(siteId, 'main')`) so navigation is content, not code.
+ */
+export default defineModel({
+  name: 'Menu',
+  table: 'menus',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'menus_site_handle_unique',
+      columns: ['site_id', 'handle'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      middleware: ['auth'],
+      uri: 'menus',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsTo: ['Site'],
+  hasMany: ['MenuItem'],
+
+  attributes: {
+    handle: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(64).matches(/^[a-z0-9-]+$/),
+      },
+      factory: faker => faker.helpers.arrayElement(['main', 'footer', 'portal']),
+    },
+
+    name: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(255),
+      },
+      factory: faker => faker.lorem.words(2),
+    },
+  },
+} as const)