@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Marketing/marketing-list-records.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  marketingListWriteData,
+  normalizeMarketingLists,
+  slugifyMarketingList,
+} from './marketing-list-records'
+
+describe('marketing list records', () => {
+  test('normalizes membership and campaign aggregates without trusting stale counters', () => {
+    const result = normalizeMarketingLists(
+      [{
+        id: 4,
+        name: 'Product News',
+        slug: 'product-news',
+        description: 'Product announcements',
+        status: 'active',
+        is_public: 1,
+        double_opt_in: 1,
+        subscriber_count: 99,
+        created_at: '2026-07-01 12:00:00',
+      }],
+      [
+        { email_list_id: 4, status: 'subscribed', count: 6 },
+        { email_list_id: 4, status: 'pending', count: 2 },
+        { email_list_id: 4, status: 'unsubscribed', count: 3 },
+        { email_list_id: 4, status: 'bounced', count: 1 },
+      ],
+      [{ email_list_id: 4, count: 2 }],
+      [{ email_list_id: 4, count: 3, last_sent_at: '2026-07-29 10:00:00' }],
+    )
+
+    expect(result.records[0]).toMatchObject({
+      id: '4',
+      subscriberCount: 8,
+      activeCount: 6,
+      unsubscribedCount: 3,
+      bouncedCount: 1,
+      storedSubscriberCount: 99,
+      countDrift: true,
+      campaignCount: 3,
+      lastSentAt: '2026-07-29 10:00:00',
+    })
+    expect(result.summary).toEqual({
+      total: 1,
+      active: 1,
+      subscribers: 8,
+      newThisWeek: 2,
+      campaigns: 3,
+      counterDriftLists: 1,
+    })
+  })
+
+  test('normalizes dashboard writes and derives a stable slug', () => {
+    expect(slugifyMarketingList(' Product & Release News! ')).toBe('product-release-news')
+    expect(marketingListWriteData({
+      name: ' Product News ',
+      slug: '',
+      description: ' Weekly updates ',
+      status: 'active',
+      isPublic: true,
+      doubleOptIn: false,
+    })).toEqual({
+      name: 'Product News',
+      slug: 'product-news',
+      description: 'Weekly updates',
+      status: 'active',
+      isPublic: 1,
+      doubleOptIn: 0,
+    })
+  })
+})

package/app/Actions/Dashboard/Marketing/marketing-list-records.ts

@@ -0,0 +1,161 @@
+export type MarketingListStatus = 'active' | 'inactive' | 'archived'
+
+export interface MarketingListRecord {
+  id: string
+  name: string
+  slug: string
+  description: string
+  status: MarketingListStatus
+  isPublic: boolean
+  doubleOptIn: boolean
+  subscriberCount: number
+  activeCount: number
+  unsubscribedCount: number
+  bouncedCount: number
+  storedSubscriberCount: number
+  countDrift: boolean
+  campaignCount: number
+  lastSentAt: string
+  createdAt: string
+}
+
+export interface MarketingListSummary {
+  total: number
+  active: number
+  subscribers: number
+  newThisWeek: number
+  campaigns: number
+  counterDriftLists: number
+}
+
+function value(record: any, ...keys: string[]): unknown {
+  for (const key of keys) {
+    const result = typeof record?.get === 'function' ? record.get(key) : record?.[key]
+    if (result !== null && result !== undefined)
+      return result
+  }
+  return undefined
+}
+
+function text(input: unknown): string {
+  return input === null || input === undefined ? '' : String(input)
+}
+
+function number(input: unknown): number {
+  const result = Number(input)
+  return Number.isFinite(result) && result >= 0 ? result : 0
+}
+
+function boolean(input: unknown): boolean {
+  return input === true || input === 1 || input === '1' || input === 'true'
+}
+
+function status(input: unknown): MarketingListStatus {
+  const normalized = text(input).toLowerCase()
+  return ['active', 'inactive', 'archived'].includes(normalized)
+    ? normalized as MarketingListStatus
+    : 'inactive'
+}
+
+function countsByList(rows: any[]): Map<string, Record<string, number>> {
+  const counts = new Map<string, Record<string, number>>()
+  for (const row of rows) {
+    const listId = text(value(row, 'email_list_id', 'emailListId'))
+    const state = text(value(row, 'status')).toLowerCase()
+    if (!listId || !state)
+      continue
+    const current = counts.get(listId) || {}
+    current[state] = number(value(row, 'count'))
+    counts.set(listId, current)
+  }
+  return counts
+}
+
+export function normalizeMarketingLists(
+  listRows: any[],
+  membershipRows: any[],
+  newMembershipRows: any[],
+  campaignRows: any[],
+): { records: MarketingListRecord[], summary: MarketingListSummary } {
+  const memberships = countsByList(membershipRows)
+  const newMemberships = new Map(newMembershipRows.map(row => [
+    text(value(row, 'email_list_id', 'emailListId')),
+    number(value(row, 'count')),
+  ]))
+  const campaigns = new Map(campaignRows.map(row => [
+    text(value(row, 'email_list_id', 'emailListId')),
+    {
+      count: number(value(row, 'count')),
+      lastSentAt: text(value(row, 'last_sent_at', 'lastSentAt')),
+    },
+  ]))
+
+  const records = listRows.map((list): MarketingListRecord => {
+    const id = text(value(list, 'id'))
+    const membership = memberships.get(id) || {}
+    const subscribed = membership.subscribed || 0
+    const pending = membership.pending || 0
+    const storedSubscriberCount = number(value(list, 'subscriber_count', 'subscriberCount'))
+    const campaign = campaigns.get(id)
+    return {
+      id,
+      name: text(value(list, 'name')),
+      slug: text(value(list, 'slug')),
+      description: text(value(list, 'description')),
+      status: status(value(list, 'status')),
+      isPublic: boolean(value(list, 'is_public', 'isPublic')),
+      doubleOptIn: boolean(value(list, 'double_opt_in', 'doubleOptIn')),
+      subscriberCount: subscribed + pending,
+      activeCount: subscribed,
+      unsubscribedCount: membership.unsubscribed || 0,
+      bouncedCount: membership.bounced || 0,
+      storedSubscriberCount,
+      countDrift: storedSubscriberCount !== subscribed + pending,
+      campaignCount: campaign?.count || 0,
+      lastSentAt: campaign?.lastSentAt || '',
+      createdAt: text(value(list, 'created_at', 'createdAt')),
+    }
+  })
+
+  return {
+    records,
+    summary: {
+      total: records.length,
+      active: records.filter(record => record.status === 'active').length,
+      subscribers: records.reduce((sum, record) => sum + record.subscriberCount, 0),
+      newThisWeek: [...newMemberships.values()].reduce((sum, count) => sum + count, 0),
+      campaigns: records.reduce((sum, record) => sum + record.campaignCount, 0),
+      counterDriftLists: records.filter(record => record.countDrift).length,
+    },
+  }
+}
+
+export function slugifyMarketingList(input: string): string {
+  return input
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]+/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+export function marketingListWriteData(input: Record<string, unknown>): {
+  name: string
+  slug: string
+  description: string
+  status: MarketingListStatus
+  isPublic: number
+  doubleOptIn: number
+} {
+  const name = text(input.name).trim()
+  const slug = slugifyMarketingList(text(input.slug).trim() || name)
+  return {
+    name,
+    slug,
+    description: text(input.description).trim(),
+    status: status(input.status),
+    isPublic: boolean(input.isPublic ?? input.is_public) ? 1 : 0,
+    doubleOptIn: boolean(input.doubleOptIn ?? input.double_opt_in) ? 1 : 0,
+  }
+}

package/app/Actions/Dashboard/Marketing/social-post-records.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  normalizeSocialPosts,
+  socialPostWriteData,
+  validateSocialPostSchedule,
+} from './social-post-records'
+
+const now = new Date('2026-07-29T12:00:00.000Z')
+
+describe('social post records', () => {
+  test('normalizes persisted engagement and User relationships', () => {
+    const result = normalizeSocialPosts(
+      [{
+        id: 8,
+        content: 'A persisted update',
+        platform: 'linkedin',
+        status: 'published',
+        published_at: '2026-07-29 10:00:00',
+        likes: 12,
+        shares: 4,
+        comments: 3,
+        reach: 900,
+        user_id: 2,
+      }],
+      [{ id: 2, name: 'Ada Lovelace', email: 'ada@example.com' }],
+    )
+
+    expect(result.records[0]).toMatchObject({
+      id: '8',
+      authorName: 'Ada Lovelace',
+      authorEmail: 'ada@example.com',
+      engagement: 19,
+      reach: 900,
+    })
+    expect(result.summary).toEqual({
+      total: 1,
+      published: 1,
+      scheduled: 0,
+      drafts: 0,
+      failed: 0,
+      reach: 900,
+      engagement: 19,
+    })
+  })
+
+  test('maps schedule writes and rejects non-future schedules', () => {
+    const valid = socialPostWriteData({
+      content: 'Schedule me',
+      platform: 'instagram',
+      status: 'scheduled',
+      scheduledAt: '2026-07-30 12:00:00',
+      userId: 4,
+    }, now)
+    expect(valid).toMatchObject({
+      content: 'Schedule me',
+      platform: 'instagram',
+      status: 'scheduled',
+      scheduled_at: '2026-07-30 12:00:00',
+      user_id: 4,
+    })
+    expect(validateSocialPostSchedule(valid, now)).toBe('')
+
+    const stale = socialPostWriteData({
+      content: 'Too late',
+      platform: 'twitter',
+      status: 'scheduled',
+      scheduledAt: '2026-07-28 12:00:00',
+    }, now)
+    expect(validateSocialPostSchedule(stale, now)).toBe('Schedule time must be in the future.')
+  })
+})

package/app/Actions/Dashboard/Marketing/social-post-records.ts

@@ -0,0 +1,163 @@
+export type SocialPostPlatform = 'twitter' | 'facebook' | 'instagram' | 'linkedin' | 'tiktok' | 'youtube'
+export type SocialPostStatus = 'draft' | 'scheduled' | 'published' | 'failed'
+
+export interface SocialPostRecord {
+  id: string
+  content: string
+  platform: SocialPostPlatform
+  status: SocialPostStatus
+  scheduledAt: string
+  publishedAt: string
+  likes: number
+  shares: number
+  comments: number
+  reach: number
+  engagement: number
+  imageUrl: string
+  externalId: string
+  userId: string
+  authorName: string
+  authorEmail: string
+  createdAt: string
+}
+
+export interface SocialPostSummary {
+  total: number
+  published: number
+  scheduled: number
+  drafts: number
+  failed: number
+  reach: number
+  engagement: number
+}
+
+export interface SocialPostUserOption {
+  id: string
+  name: string
+  email: string
+}
+
+function value(record: any, ...keys: string[]): unknown {
+  for (const key of keys) {
+    const result = typeof record?.get === 'function' ? record.get(key) : record?.[key]
+    if (result !== null && result !== undefined)
+      return result
+  }
+  return undefined
+}
+
+function text(input: unknown): string {
+  return input === null || input === undefined ? '' : String(input)
+}
+
+function number(input: unknown): number {
+  const result = Number(input)
+  return Number.isFinite(result) && result >= 0 ? result : 0
+}
+
+function platform(input: unknown): SocialPostPlatform {
+  const normalized = text(input).toLowerCase()
+  return ['twitter', 'facebook', 'instagram', 'linkedin', 'tiktok', 'youtube'].includes(normalized)
+    ? normalized as SocialPostPlatform
+    : 'twitter'
+}
+
+function status(input: unknown): SocialPostStatus {
+  const normalized = text(input).toLowerCase()
+  return ['draft', 'scheduled', 'published', 'failed'].includes(normalized)
+    ? normalized as SocialPostStatus
+    : 'draft'
+}
+
+export function normalizeSocialPosts(
+  postRows: any[],
+  userRows: any[],
+): { records: SocialPostRecord[], summary: SocialPostSummary, users: SocialPostUserOption[] } {
+  const users = userRows.map((user): SocialPostUserOption => ({
+    id: text(value(user, 'id')),
+    name: text(value(user, 'name')) || text(value(user, 'email')) || `User ${text(value(user, 'id'))}`,
+    email: text(value(user, 'email')),
+  }))
+  const usersById = new Map(users.map(user => [user.id, user]))
+
+  const records = postRows.map((post): SocialPostRecord => {
+    const userId = text(value(post, 'user_id', 'userId'))
+    const author = usersById.get(userId)
+    const likes = number(value(post, 'likes'))
+    const shares = number(value(post, 'shares'))
+    const comments = number(value(post, 'comments'))
+    return {
+      id: text(value(post, 'id')),
+      content: text(value(post, 'content')),
+      platform: platform(value(post, 'platform')),
+      status: status(value(post, 'status')),
+      scheduledAt: text(value(post, 'scheduled_at', 'scheduledAt')),
+      publishedAt: text(value(post, 'published_at', 'publishedAt')),
+      likes,
+      shares,
+      comments,
+      reach: number(value(post, 'reach')),
+      engagement: likes + shares + comments,
+      imageUrl: text(value(post, 'image_url', 'imageUrl')),
+      externalId: text(value(post, 'external_id', 'externalId')),
+      userId,
+      authorName: author?.name || (userId ? `User ${userId}` : 'Unassigned'),
+      authorEmail: author?.email || '',
+      createdAt: text(value(post, 'created_at', 'createdAt')),
+    }
+  })
+
+  return {
+    records,
+    summary: {
+      total: records.length,
+      published: records.filter(record => record.status === 'published').length,
+      scheduled: records.filter(record => record.status === 'scheduled').length,
+      drafts: records.filter(record => record.status === 'draft').length,
+      failed: records.filter(record => record.status === 'failed').length,
+      reach: records.reduce((sum, record) => sum + record.reach, 0),
+      engagement: records.reduce((sum, record) => sum + record.engagement, 0),
+    },
+    users,
+  }
+}
+
+export function socialPostWriteData(input: Record<string, unknown>, now = new Date()): {
+  content: string
+  platform: SocialPostPlatform
+  status: SocialPostStatus
+  scheduled_at: string | null
+  published_at: string | null
+  image_url: string | null
+  user_id: number | null
+} {
+  const postStatus = status(input.status)
+  const scheduledAt = text(input.scheduledAt ?? input.scheduled_at).trim()
+  const publishedAt = text(input.publishedAt ?? input.published_at).trim()
+  const imageUrl = text(input.imageUrl ?? input.image_url).trim()
+  const userId = Number(input.userId ?? input.user_id)
+  return {
+    content: text(input.content).trim(),
+    platform: platform(input.platform),
+    status: postStatus,
+    scheduled_at: scheduledAt || null,
+    published_at: postStatus === 'published'
+      ? publishedAt || now.toISOString().slice(0, 19).replace('T', ' ')
+      : publishedAt || null,
+    image_url: imageUrl || null,
+    user_id: Number.isInteger(userId) && userId > 0 ? userId : null,
+  }
+}
+
+export function validateSocialPostSchedule(data: ReturnType<typeof socialPostWriteData>, now = new Date()): string {
+  if (data.status !== 'scheduled')
+    return ''
+  if (!data.scheduled_at)
+    return 'Scheduled posts require a schedule time.'
+  const timestamp = new Date(data.scheduled_at.replace(' ', 'T')).getTime()
+  if (!Number.isFinite(timestamp))
+    return 'Enter a valid schedule time.'
+  if (timestamp <= now.getTime())
+    return 'Schedule time must be in the future.'
+  return ''
+}

package/app/Actions/Dashboard/Models/GetModels.ts

@@ -2,6 +2,7 @@ import type { Model } from '@stacksjs/types'
 import { Glob } from 'bun'
 import { Action } from '@stacksjs/actions'
 import { path } from '@stacksjs/path'
+import { countRows } from '../../../../resources/functions/dashboard/data'
 
 export default new Action({
   name: 'GetModels',
@@ -30,10 +31,9 @@ export default new Action({
       displayModels.length = 8
     displayModels.sort((a, b) => (a.name || '').localeCompare(b.name || ''))
 
-    return displayModels.map(model => ({
+    return await Promise.all(displayModels.map(async model => ({
       model: model.name,
-      // TODO: implement this total logic
-      total: Math.floor(Math.random() * (999 - 10 + 1)) + 10,
-    }))
+      total: await countRows(model),
+    })))
   },
 })

package/app/Actions/Dashboard/Models/GetSubscriberCount.ts

@@ -1,5 +1,5 @@
 import { Action } from '@stacksjs/actions'
-// import { Subscriber } from '@stacksjs/orm'
+import { Subscriber } from '@stacksjs/orm'
 
 export default new Action({
   name: 'GetSubscriberCount',
@@ -7,6 +7,6 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    // return Subscriber.count()
+    return await Subscriber.count()
   },
 })

package/app/Actions/Dashboard/Models/ModelDestroyAction.ts

@@ -14,7 +14,7 @@ export default new Action({
   method: 'DELETE',
   apiResponse: true,
   async handle(req: { getParam?: (name: string) => unknown, route?: { params?: { slug?: string, id?: string } } }) {
-    const resolved = await resolveWritableModel(String(req?.getParam?.('slug') ?? req?.route?.params?.slug ?? ''))
+    const resolved = await resolveWritableModel(String(req?.getParam?.('slug') ?? req?.route?.params?.slug ?? ''), 'destroy')
     if ('error' in resolved)
       return { ok: false, error: resolved.error }