@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Library/library-source.ts

@@ -0,0 +1,205 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { extname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { componentsPath, functionsPath } from '@stacksjs/path'
+
+export interface FunctionSourceRow {
+  name: string
+  path: string
+  extension: string
+  bytes: number
+  createdAt: string
+  updatedAt: string
+}
+
+export interface WorkspacePackageRow {
+  name: string
+  version: string
+  description: string
+  license: string
+  private: boolean
+  path: string
+  url: string
+  dependencyCount: number
+}
+
+export interface ComponentSourceRow {
+  name: string
+  path: string
+  category: string
+  bytes: number
+  updatedAt: string
+}
+
+function sourceFiles(root: string, extensions: string[]): string[] {
+  if (!existsSync(root))
+    return []
+
+  const files: string[] = []
+  const visit = (directory: string): void => {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const absolute = join(directory, entry.name)
+      if (entry.isDirectory()) {
+        visit(absolute)
+        continue
+      }
+
+      if (entry.isFile() && extensions.includes(extname(entry.name)))
+        files.push(absolute)
+    }
+  }
+
+  visit(root)
+  return files
+}
+
+export function functionSourceRows(projectRoot = process.cwd()): FunctionSourceRow[] {
+  const root = projectRoot === process.cwd()
+    ? functionsPath()
+    : join(projectRoot, 'resources', 'functions')
+
+  return sourceFiles(root, ['.ts', '.tsx', '.js', '.jsx'])
+    .map((absolute) => {
+      const stats = statSync(absolute)
+      const path = relative(projectRoot, absolute).split(sep).join('/')
+      const extension = extname(absolute)
+
+      return {
+        name: relative(root, absolute).split(sep).join('/').slice(0, -extension.length),
+        path,
+        extension: extension.slice(1),
+        bytes: stats.size,
+        createdAt: stats.birthtime.toISOString(),
+        updatedAt: stats.mtime.toISOString(),
+      }
+    })
+    .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+export function componentSourceRows(projectRoot = process.cwd()): ComponentSourceRow[] {
+  const root = projectRoot === process.cwd()
+    ? componentsPath()
+    : join(projectRoot, 'resources', 'components')
+
+  return sourceFiles(root, ['.stx'])
+    .map((absolute) => {
+      const stats = statSync(absolute)
+      const relativePath = relative(root, absolute).split(sep).join('/')
+      const segments = relativePath.split('/')
+
+      return {
+        name: relativePath.slice(0, -extname(relativePath).length),
+        path: relative(projectRoot, absolute).split(sep).join('/'),
+        category: segments.length > 1 ? segments[0] || 'App' : 'App',
+        bytes: stats.size,
+        updatedAt: stats.mtime.toISOString(),
+      }
+    })
+    .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function externalUrl(value: unknown): string {
+  const raw = typeof value === 'string'
+    ? value
+    : value && typeof value === 'object' && 'url' in value
+      ? String((value as { url?: unknown }).url || '')
+      : ''
+
+  const normalized = raw
+    .trim()
+    .replace(/^git\+/, '')
+    .replace(/^git:\/\//, 'https://')
+    .replace(/\.git$/, '')
+
+  if (!normalized)
+    return ''
+
+  try {
+    const url = new URL(normalized)
+    return url.protocol === 'https:' || url.protocol === 'http:' ? url.toString() : ''
+  }
+  catch {
+    return ''
+  }
+}
+
+function sourceError(source: string, error: unknown): Error {
+  const detail = error instanceof Error ? error.message : String(error)
+  return new Error(`Could not read dashboard library source ${source}: ${detail}`)
+}
+
+export function workspacePackageRows(projectRoot = process.cwd()): WorkspacePackageRow[] {
+  const lockPath = join(projectRoot, 'bun.lock')
+  if (!existsSync(lockPath))
+    throw new Error('Could not read dashboard library source bun.lock: file does not exist')
+
+  let lockfile: { workspaces?: Record<string, unknown> }
+  try {
+    lockfile = Bun.JSONC.parse(readFileSync(lockPath, 'utf8')) as {
+      workspaces?: Record<string, unknown>
+    }
+  }
+  catch (error) {
+    throw sourceError('bun.lock', error)
+  }
+
+  if (lockfile.workspaces !== undefined && (
+    !lockfile.workspaces
+    || typeof lockfile.workspaces !== 'object'
+    || Array.isArray(lockfile.workspaces)
+  )) {
+    throw new TypeError('Could not read dashboard library source bun.lock: workspaces must be an object')
+  }
+
+  return Object.keys(lockfile.workspaces || {})
+    .filter(Boolean)
+    .map((workspacePath) => {
+      const manifestPath = resolve(projectRoot, workspacePath, 'package.json')
+      const manifestRelativePath = relative(projectRoot, manifestPath)
+      if (
+        manifestRelativePath === '..'
+        || manifestRelativePath.startsWith(`..${sep}`)
+        || isAbsolute(manifestRelativePath)
+      ) {
+        throw new Error(`Could not read dashboard library source ${workspacePath}: workspace escapes the project root`)
+      }
+
+      if (!existsSync(manifestPath))
+        throw new Error(`Could not read dashboard library source ${workspacePath}/package.json: file does not exist`)
+
+      let manifest: {
+        name?: string
+        version?: string
+        description?: string
+        license?: string
+        private?: boolean
+        homepage?: string
+        repository?: unknown
+        dependencies?: Record<string, string>
+        peerDependencies?: Record<string, string>
+      }
+      try {
+        manifest = Bun.JSONC.parse(readFileSync(manifestPath, 'utf8')) as typeof manifest
+      }
+      catch (error) {
+        throw sourceError(`${workspacePath}/package.json`, error)
+      }
+
+      if (typeof manifest.name !== 'string' || !manifest.name.trim())
+        throw new TypeError(`Could not read dashboard library source ${workspacePath}/package.json: package name is required`)
+
+      return {
+        name: manifest.name.trim(),
+        version: manifest.version || '',
+        description: manifest.description || '',
+        license: manifest.license || '',
+        private: Boolean(manifest.private),
+        path: workspacePath,
+        url: externalUrl(manifest.homepage) || externalUrl(manifest.repository),
+        dependencyCount: Object.keys({
+          ...manifest.dependencies,
+          ...manifest.peerDependencies,
+        }).length,
+      } satisfies WorkspacePackageRow
+    })
+    .sort((a, b) => a.name.localeCompare(b.name))
+}

package/app/Actions/Dashboard/Marketing/CampaignCancelAction.ts

@@ -0,0 +1,26 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { campaigns } from '@stacksjs/newsletter'
+import { Campaign } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { validateCampaignDelivery } from './campaign-delivery'
+
+export default new Action({
+  name: 'CampaignCancelAction',
+  description: 'Cancels scheduled or active email campaign delivery.',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    const campaign = await Campaign.find(id)
+    if (!campaign)
+      return response.json({ message: 'Campaign not found.' }, 404)
+
+    const validationError = validateCampaignDelivery(campaign, 'cancel')
+    if (validationError)
+      return response.json({ message: validationError }, 422)
+
+    await campaigns.cancel(id)
+    return response.json({ id, status: 'cancelled' })
+  },
+})

package/app/Actions/Dashboard/Marketing/CampaignDestroyAction.ts

@@ -0,0 +1,33 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { Campaign } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CampaignDestroyAction',
+  description: 'Deletes an unused Campaign record from the dashboard.',
+  method: 'DELETE',
+
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    const campaign = await Campaign.find(id)
+    if (!campaign)
+      return response.json({ message: 'Campaign not found.' }, 404)
+
+    const status = String(campaign.get('status') || '')
+    const sendRow = await db
+      .selectFrom('campaign_sends')
+      .select(db.fn.count('id').as('count'))
+      .where('campaign_id', '=', id)
+      .executeTakeFirst()
+    if (Number(sendRow?.count || 0) > 0 || ['scheduled', 'sending', 'sent'].includes(status)) {
+      return response.json({
+        message: 'Scheduled campaigns and campaigns with delivery history cannot be deleted.',
+      }, 409)
+    }
+
+    await campaign.delete()
+    return response.noContent()
+  },
+})

package/app/Actions/Dashboard/Marketing/CampaignIndexAction.ts

@@ -1,45 +1,59 @@
 import { Action } from '@stacksjs/actions'
-import { Campaign } from '@stacksjs/orm'
+import { config } from '@stacksjs/config'
+import { db } from '@stacksjs/database'
+import { Campaign, EmailList } from '@stacksjs/orm'
+import { normalizeCampaigns } from './campaign-records'
 
 export default new Action({
   name: 'CampaignIndexAction',
-  description: 'Returns marketing campaign data for the dashboard.',
+  description: 'Returns persisted campaigns with list membership and delivery aggregates.',
   method: 'GET',
-  async handle() {
-    try {
-      const allCampaigns = await Campaign.orderByDesc('id').get()
-
-      const campaigns = allCampaigns.map(c => ({
-        name: String(c.get('name') || ''),
-        type: String(c.get('type') || 'Email'),
-        status: String(c.get('status') || 'active'),
-        sent: String(c.get('sent_count') || c.get('sent') || '-'),
-        opened: c.get('open_rate') ? `${c.get('open_rate')}%` : '-',
-        clicked: c.get('click_rate') ? `${c.get('click_rate')}%` : '-',
-        revenue: c.get('revenue') ? `$${c.get('revenue')}` : '-',
-      }))
+  apiResponse: true,
 
-      const activeCampaigns = campaigns.filter(c => c.status === 'active').length
-
-      const stats = [
-        { label: 'Active Campaigns', value: String(activeCampaigns) },
-        { label: 'Total Sent', value: '-' },
-        { label: 'Avg Open Rate', value: '-' },
-        { label: 'Revenue Generated', value: '-' },
-      ]
+  async handle() {
+    const [
+      campaigns,
+      lists,
+      membershipRows,
+      sendRows,
+      openedRows,
+      clickedRows,
+    ] = await Promise.all([
+      Campaign.orderByDesc('id').limit(500).get(),
+      EmailList.orderBy('name', 'asc').get(),
+      db
+        .selectFrom('email_list_subscribers')
+        .select(['email_list_id', db.fn.count('id').as('count')])
+        .where('status', '=', 'subscribed')
+        .groupBy('email_list_id')
+        .execute(),
+      db
+        .selectFrom('campaign_sends')
+        .select(['campaign_id', 'status', db.fn.count('id').as('count')])
+        .groupBy(['campaign_id', 'status'])
+        .execute(),
+      db
+        .selectFrom('campaign_sends')
+        .select(['campaign_id', db.fn.count('id').as('count')])
+        .where('opened_at', 'is not', null)
+        .groupBy('campaign_id')
+        .execute(),
+      db
+        .selectFrom('campaign_sends')
+        .select(['campaign_id', db.fn.count('id').as('count')])
+        .where('clicked_at', 'is not', null)
+        .groupBy('campaign_id')
+        .execute(),
+    ])
 
-      return { campaigns, stats }
-    }
-    catch {
-      return {
-        campaigns: [],
-        stats: [
-          { label: 'Active Campaigns', value: '0' },
-          { label: 'Total Sent', value: '0' },
-          { label: 'Avg Open Rate', value: '-' },
-          { label: 'Revenue Generated', value: '-' },
-        ],
-      }
-    }
+    return normalizeCampaigns(
+      campaigns,
+      lists,
+      membershipRows,
+      sendRows,
+      openedRows,
+      clickedRows,
+      String((config as any).commerce?.currency || 'USD').toUpperCase(),
+    )
   },
 })

package/app/Actions/Dashboard/Marketing/CampaignScheduleAction.ts

@@ -0,0 +1,49 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { campaigns } from '@stacksjs/newsletter'
+import { Campaign, EmailList } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  campaignScheduleIso,
+  validateCampaignDelivery,
+} from './campaign-delivery'
+
+export default new Action({
+  name: 'CampaignScheduleAction',
+  description: 'Schedules a ready email campaign for future delivery.',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    const campaign = await Campaign.find(id)
+    if (!campaign)
+      return response.json({ message: 'Campaign not found.' }, 404)
+
+    const listId = Number(campaign.get('email_list_id') || 0)
+    const list = listId ? await EmailList.find(listId) : null
+    const memberRow = listId
+      ? await db
+          .selectFrom('email_list_subscribers')
+          .select(db.fn.count('id').as('count'))
+          .where('email_list_id', '=', listId)
+          .where('status', '=', 'subscribed')
+          .executeTakeFirst()
+      : null
+    const validationError = validateCampaignDelivery(
+      campaign,
+      'schedule',
+      Number(memberRow?.count || 0),
+      String(list?.get('status') || ''),
+    )
+    if (validationError)
+      return response.json({ message: validationError }, 422)
+
+    const schedule = campaignScheduleIso((await request.all()).scheduledAt)
+    if (schedule.error)
+      return response.json({ message: schedule.error }, 422)
+
+    await campaigns.schedule(id, schedule.value)
+    return response.json({ id, status: 'scheduled', scheduledAt: schedule.value }, 202)
+  },
+})

package/app/Actions/Dashboard/Marketing/CampaignSendAction.ts

@@ -0,0 +1,42 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { campaigns } from '@stacksjs/newsletter'
+import { Campaign, EmailList } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { validateCampaignDelivery } from './campaign-delivery'
+
+export default new Action({
+  name: 'CampaignSendAction',
+  description: 'Queues a ready email campaign for immediate delivery.',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    const campaign = await Campaign.find(id)
+    if (!campaign)
+      return response.json({ message: 'Campaign not found.' }, 404)
+
+    const listId = Number(campaign.get('email_list_id') || 0)
+    const list = listId ? await EmailList.find(listId) : null
+    const memberRow = listId
+      ? await db
+          .selectFrom('email_list_subscribers')
+          .select(db.fn.count('id').as('count'))
+          .where('email_list_id', '=', listId)
+          .where('status', '=', 'subscribed')
+          .executeTakeFirst()
+      : null
+    const validationError = validateCampaignDelivery(
+      campaign,
+      'send',
+      Number(memberRow?.count || 0),
+      String(list?.get('status') || ''),
+    )
+    if (validationError)
+      return response.json({ message: validationError }, 422)
+
+    await campaigns.sendNow(id)
+    return response.json({ id, status: 'sending' }, 202)
+  },
+})

package/app/Actions/Dashboard/Marketing/CampaignStoreAction.ts

@@ -0,0 +1,36 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { Campaign } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { campaignWriteData, validateCampaignWriteData } from './campaign-records'
+
+export default new Action({
+  name: 'CampaignStoreAction',
+  description: 'Creates a persisted Campaign record from the dashboard.',
+  method: 'POST',
+  model: Campaign,
+
+  async handle(request: RequestInstance) {
+    await request.validate()
+    const data = campaignWriteData(
+      await request.all(),
+      String((config as any).commerce?.currency || 'USD').toUpperCase(),
+    )
+    const validationError = validateCampaignWriteData(data)
+    if (validationError)
+      return response.json({ message: validationError }, 422)
+    if (['sending', 'sent'].includes(data.status))
+      return response.json({ message: 'Campaign delivery status is managed by the send pipeline.' }, 422)
+
+    const campaign = await Campaign.create({
+      ...data,
+      audience_size: 0,
+      sent_count: 0,
+      open_rate: null,
+      click_rate: null,
+      conversion_rate: null,
+    })
+    return response.json({ id: campaign.get('id') }, 201)
+  },
+})

package/app/Actions/Dashboard/Marketing/CampaignUpdateAction.ts

@@ -0,0 +1,38 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { Campaign } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { campaignWriteData, validateCampaignWriteData } from './campaign-records'
+
+export default new Action({
+  name: 'CampaignUpdateAction',
+  description: 'Updates an editable Campaign record from the dashboard.',
+  method: 'PATCH',
+  model: Campaign,
+
+  async handle(request: RequestInstance) {
+    await request.validate()
+    const id = Number(request.getParam('id'))
+    const campaign = await Campaign.find(id)
+    if (!campaign)
+      return response.json({ message: 'Campaign not found.' }, 404)
+
+    const currentStatus = String(campaign.get('status') || '')
+    if (['sending', 'sent'].includes(currentStatus))
+      return response.json({ message: 'Campaigns that entered delivery cannot be edited.' }, 409)
+
+    const data = campaignWriteData(
+      await request.all(),
+      String((config as any).commerce?.currency || 'USD').toUpperCase(),
+    )
+    const validationError = validateCampaignWriteData(data)
+    if (validationError)
+      return response.json({ message: validationError }, 422)
+    if (['sending', 'sent'].includes(data.status))
+      return response.json({ message: 'Campaign delivery status is managed by the send pipeline.' }, 422)
+
+    await campaign.update(data)
+    return response.json({ id })
+  },
+})

package/app/Actions/Dashboard/Marketing/ListDestroyAction.ts

@@ -0,0 +1,41 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { EmailList } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'MarketingListDestroyAction',
+  description: 'Deletes an unused EmailList record from the dashboard.',
+  method: 'DELETE',
+
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    const list = await EmailList.find(id)
+    if (!list)
+      return response.json({ message: 'Email list not found.' }, 404)
+
+    const [membership, campaign] = await Promise.all([
+      db
+        .selectFrom('email_list_subscribers')
+        .select(db.fn.count('id').as('count'))
+        .where('email_list_id', '=', id)
+        .executeTakeFirst(),
+      db
+        .selectFrom('campaigns')
+        .select(db.fn.count('id').as('count'))
+        .where('email_list_id', '=', id)
+        .executeTakeFirst(),
+    ])
+    const membershipCount = Number(membership?.count || 0)
+    const campaignCount = Number(campaign?.count || 0)
+    if (membershipCount > 0 || campaignCount > 0) {
+      return response.json({
+        message: 'Archive this list instead. Lists with memberships or campaigns cannot be deleted.',
+      }, 409)
+    }
+
+    await list.delete()
+    return response.noContent()
+  },
+})

package/app/Actions/Dashboard/Marketing/ListIndexAction.ts

@@ -1,43 +1,46 @@
 import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
 import { EmailList } from '@stacksjs/orm'
+import { normalizeMarketingLists } from './marketing-list-records'
 
 export default new Action({
   name: 'ListIndexAction',
-  description: 'Returns mailing list data for the dashboard.',
+  description: 'Returns persisted email lists with membership and campaign aggregates.',
   method: 'GET',
-  async handle() {
-    try {
-      const allLists = await EmailList.all()
-
-      const lists = allLists.map(l => ({
-        name: String(l.get('name') || ''),
-        members: Number(l.get('member_count') || l.get('subscribers_count') || 0),
-        growth: String(l.get('growth') || '+0'),
-        status: String(l.get('status') || 'active'),
-        lastSent: String(l.get('last_sent_at') || '-'),
-      }))
+  apiResponse: true,
 
-      const totalSubscribers = lists.reduce((s, l) => s + l.members, 0)
+  async handle() {
+    const weekStart = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+      .toISOString()
+      .slice(0, 19)
+      .replace('T', ' ')
 
-      const stats = [
-        { label: 'Total Subscribers', value: String(totalSubscribers) },
-        { label: 'New This Week', value: '-' },
-        { label: 'Unsubscribed', value: '-' },
-        { label: 'Avg Open Rate', value: '-' },
-      ]
+    const [lists, membershipRows, newMembershipRows, campaignRows] = await Promise.all([
+      EmailList.orderBy('name', 'asc').get(),
+      db
+        .selectFrom('email_list_subscribers')
+        .select(['email_list_id', 'status', db.fn.count('id').as('count')])
+        .groupBy(['email_list_id', 'status'])
+        .execute(),
+      db
+        .selectFrom('email_list_subscribers')
+        .select(['email_list_id', db.fn.count('id').as('count')])
+        .where('status', '=', 'subscribed')
+        .where('subscribed_at', '>=', weekStart)
+        .groupBy('email_list_id')
+        .execute(),
+      db
+        .selectFrom('campaigns')
+        .select([
+          'email_list_id',
+          db.fn.count('id').as('count'),
+          db.fn.max('sent_at').as('last_sent_at'),
+        ])
+        .where('email_list_id', 'is not', null)
+        .groupBy('email_list_id')
+        .execute(),
+    ])
 
-      return { lists, stats }
-    }
-    catch {
-      return {
-        lists: [],
-        stats: [
-          { label: 'Total Subscribers', value: '0' },
-          { label: 'New This Week', value: '0' },
-          { label: 'Unsubscribed', value: '0' },
-          { label: 'Avg Open Rate', value: '-' },
-        ],
-      }
-    }
+    return normalizeMarketingLists(lists, membershipRows, newMembershipRows, campaignRows)
   },
 })