@stacksjs/defaults 0.70.58 → 0.70.60

package/app/Actions/Dashboard/Kanban/LabelUpdateAction.ts

@@ -0,0 +1,83 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface LabelInput {
+  name?: unknown
+  color?: unknown
+}
+
+/**
+ * `PATCH /api/dashboard/kanban/labels/:id` (stacksjs/stacks#1846 Phase 3).
+ *
+ * Partial update for label name + color. `board_id` is not movable —
+ * a label on board A renaming to "Bug" must not collide with a
+ * pre-existing "Bug" label on board A (caught up front, rather than
+ * letting the unique index fire its own error).
+ */
+export default new Action({
+  name: 'Kanban Label Update',
+  description: 'Partial update of a label name / color.',
+  method: 'PATCH',
+  apiResponse: true,
+  async handle(request) {
+    const rawId = (request as any)?.params?.id ?? (request as any)?.param?.('id') ?? null
+    const id = Number(rawId)
+    if (!Number.isFinite(id) || id <= 0) {
+      return { error: 'Invalid label id', status: 400 }
+    }
+
+    const body = (request as any).jsonBody as LabelInput | undefined ?? {}
+    const set: Record<string, unknown> = {}
+    let renamingTo: string | null = null
+
+    if (typeof body.name === 'string') {
+      const name = body.name.trim()
+      if (!name || name.length > 60) {
+        return { error: '`name` must be 1-60 characters.', status: 400 }
+      }
+      set.name = name
+      renamingTo = name
+    }
+    if (typeof body.color === 'string' && body.color)
+      set.color = body.color
+
+    if (Object.keys(set).length === 0)
+      return { error: 'No updatable fields provided.', status: 400 }
+
+    try {
+      // Fetch current label to know which board to check for the
+      // rename collision.
+      const existing = await db.unsafe(
+        'SELECT id, board_id, name FROM labels WHERE id = ? LIMIT 1',
+        [id],
+      ).execute() as Array<{ id: number, board_id: number, name: string }>
+      const current = existing?.[0]
+      if (!current)
+        return { error: 'Label not found', status: 404 }
+
+      if (renamingTo && renamingTo !== current.name) {
+        const dup = await db.unsafe(
+          'SELECT id FROM labels WHERE board_id = ? AND name = ? AND id != ? LIMIT 1',
+          [current.board_id, renamingTo, id],
+        ).execute() as Array<{ id: number }>
+        if (dup?.length)
+          return { error: 'A label with that name already exists on this board.', status: 409 }
+      }
+
+      await db.updateTable('labels').set(set as any).where('id', '=', id).execute()
+
+      const rows = await db.unsafe(
+        'SELECT id, board_id, name, color FROM labels WHERE id = ? LIMIT 1',
+        [id],
+      ).execute() as Array<{ id: number, board_id: number, name: string, color: string }>
+      const r = rows?.[0]
+      if (!r)
+        return { error: 'Label not found', status: 404 }
+      return { label: { id: r.id, boardId: r.board_id, name: r.name, color: r.color } }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] LabelUpdateAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/UsersListAction.ts

@@ -0,0 +1,36 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+/**
+ * `GET /api/dashboard/kanban/users` (stacksjs/stacks#1846 Phase 3).
+ *
+ * Lightweight user list for the assignee picker on the card detail
+ * modal. Returns `{ id, name, email }` only — no roles, no profile,
+ * no avatars. The modal renders initials from `name`, so anything
+ * heavier would be wasted bytes.
+ *
+ * Scoped to the kanban route group so we don't conflate this with
+ * the wider `/api/dashboard/users` (which the dashboard's Data
+ * section uses and may eventually carry richer profile data). Drift
+ * between the two is fine — different consumers, different needs.
+ */
+export default new Action({
+  name: 'Kanban Users List',
+  description: 'Lightweight user list for the kanban assignee picker.',
+  method: 'GET',
+  apiResponse: true,
+  async handle() {
+    try {
+      const rows = await db.unsafe(
+        'SELECT id, name, email FROM users ORDER BY name ASC, id ASC LIMIT 500',
+      ).execute() as Array<{ id: number, name: string | null, email: string | null }>
+      return {
+        users: (rows ?? []).map(r => ({ id: r.id, name: r.name, email: r.email })),
+      }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] UsersListAction failed:', err)
+      return { users: [], error: err instanceof Error ? err.message : 'unknown error' }
+    }
+  },
+})

package/app/Actions/Dashboard/Library/CreateComponent.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateFunction',
+  description: 'Creates a new function.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/Library/CreateFunction.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateFunction',
+  description: 'Creates a new function.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/Library/DependencyIndexAction.ts

@@ -0,0 +1,92 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'DependencyIndexAction',
+  description: 'Returns dependency data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const { readFileSync, readdirSync } = await import('node:fs')
+    const { join } = await import('node:path')
+    const projectRoot = process.cwd()
+
+    const declared: Array<Record<string, unknown>> = []
+    const transitive: Array<Record<string, unknown>> = []
+    let workspaceCount = 0
+    let thirdPartyCount = 0
+    let transitiveCount = 0
+    let totalCount = 0
+
+    try {
+      const declaredSet: Record<string, boolean> = {}
+      const lockPath = join(projectRoot, 'pantry.lock')
+      const lockfile = JSON.parse(readFileSync(lockPath, 'utf-8'))
+      const workspaces = lockfile.workspaces || {}
+
+      for (const wsKey of Object.keys(workspaces)) {
+        const ws = workspaces[wsKey]
+        const allDeps = { ...ws.dependencies, ...ws.devDependencies }
+        for (const depName of Object.keys(allDeps)) {
+          if (declaredSet[depName]) continue
+          declaredSet[depName] = true
+          const version = allDeps[depName]
+          const isWorkspace = version === 'workspace:*' || depName.startsWith('@stacksjs/')
+          declared.push({ name: depName, version, isWorkspace, isScoped: depName.includes('/') })
+        }
+      }
+      declared.sort((a, b) => String(a.name).localeCompare(String(b.name)))
+
+      // Scan pantry directory for transitive deps
+      const pantryDir = join(projectRoot, 'pantry')
+      const entries = readdirSync(pantryDir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        if (entry.name.startsWith('@')) {
+          const scopeDir = join(pantryDir, entry.name)
+          try {
+            const scopedEntries = readdirSync(scopeDir, { withFileTypes: true })
+            for (const se of scopedEntries) {
+              if (!se.isDirectory()) continue
+              const pkgName = `${entry.name}/${se.name}`
+              if (!declaredSet[pkgName]) {
+                let ver = '0.0.0'
+                try { ver = JSON.parse(readFileSync(join(scopeDir, se.name, 'package.json'), 'utf-8')).version || '0.0.0' }
+                catch { /* ignore */ }
+                transitive.push({ name: pkgName, version: ver, isScoped: true })
+              }
+            }
+          }
+          catch { /* ignore */ }
+        }
+        else if (entry.name !== '.bin' && entry.name !== 'node_modules') {
+          if (!declaredSet[entry.name]) {
+            let ver = '0.0.0'
+            try { ver = JSON.parse(readFileSync(join(pantryDir, entry.name, 'package.json'), 'utf-8')).version || '0.0.0' }
+            catch { /* ignore */ }
+            transitive.push({ name: entry.name, version: ver, isScoped: false })
+          }
+        }
+      }
+      transitive.sort((a, b) => String(a.name).localeCompare(String(b.name)))
+
+      workspaceCount = declared.filter(p => p.isWorkspace).length
+      thirdPartyCount = declared.length - workspaceCount
+      transitiveCount = transitive.length
+      totalCount = declared.length + transitiveCount
+    }
+    catch {
+      // pantry.lock or pantry/ may not exist
+    }
+
+    const thirdParty = declared.filter(p => !p.isWorkspace)
+    const workspace = declared.filter(p => p.isWorkspace)
+
+    const stats = [
+      { label: 'Declared', value: String(declared.length) },
+      { label: 'Third-Party', value: String(thirdPartyCount) },
+      { label: 'Workspace', value: String(workspaceCount) },
+      { label: 'Transitive', value: String(transitiveCount) },
+    ]
+
+    return { declared, thirdParty, workspace, transitive, stats, totalCount, transitiveCount, workspaceCount, thirdPartyCount }
+  },
+})

package/app/Actions/Dashboard/Library/GetAverageReleaseTime.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Library } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetAverageReleaseTime',
+  description: 'Gets the average release time of your library.',
+  apiResponse: true,
+
+  async handle() {
+    // return Library.averageReleaseTime()
+  },
+})

package/app/Actions/Dashboard/Library/GetComponents.ts

@@ -0,0 +1,24 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'GetComponents',
+  description: 'Gets your UI components.',
+  method: 'GET',
+
+  async handle() {
+    const components = [
+      { name: 'Button', category: 'Forms', instances: 47, description: 'Interactive button component with variants' },
+      { name: 'Input', category: 'Forms', instances: 38, description: 'Text input with validation support' },
+      { name: 'Card', category: 'Layout', instances: 23, description: 'Container card with header and footer slots' },
+      { name: 'Modal', category: 'Overlay', instances: 12, description: 'Dialog modal with backdrop' },
+      { name: 'Table', category: 'Data', instances: 18, description: 'Data table with sorting and pagination' },
+      { name: 'Badge', category: 'Display', instances: 34, description: 'Status badge with color variants' },
+      { name: 'Avatar', category: 'Display', instances: 21, description: 'User avatar with fallback' },
+      { name: 'Dropdown', category: 'Navigation', instances: 15, description: 'Dropdown menu with items' },
+    ]
+
+    const categories = ['All', 'Forms', 'Layout', 'Overlay', 'Data', 'Display', 'Navigation']
+
+    return { components, categories }
+  },
+})

package/app/Actions/Dashboard/Library/GetComponentsDownloadCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Library } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetComponentsDownloadCount',
+  description: 'Gets the total number of component downloads.',
+  apiResponse: true,
+
+  async handle() {
+    // return Library.componentsDownloadCount()
+  },
+})

package/app/Actions/Dashboard/Library/GetDownloadCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Library } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetDownloadCount',
+  description: 'Gets the total number of downloads.',
+  apiResponse: true,
+
+  async handle() {
+    // return Library.downloadCount()
+  },
+})

package/app/Actions/Dashboard/Library/GetFunctions.ts

@@ -0,0 +1,22 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'GetFunctions',
+  description: 'Gets your utility functions.',
+  method: 'GET',
+
+  async handle() {
+    const functions = [
+      { name: 'formatDate', category: 'Date', calls: 1247, description: 'Format dates in various formats' },
+      { name: 'validateEmail', category: 'Validation', calls: 892, description: 'Validate email addresses' },
+      { name: 'slugify', category: 'String', calls: 456, description: 'Convert strings to URL slugs' },
+      { name: 'debounce', category: 'Utility', calls: 234, description: 'Debounce function calls' },
+      { name: 'formatCurrency', category: 'Number', calls: 678, description: 'Format numbers as currency' },
+      { name: 'parseJSON', category: 'Data', calls: 345, description: 'Safely parse JSON strings' },
+      { name: 'truncate', category: 'String', calls: 567, description: 'Truncate strings with ellipsis' },
+      { name: 'capitalize', category: 'String', calls: 423, description: 'Capitalize first letter' },
+    ]
+
+    return { functions }
+  },
+})

package/app/Actions/Dashboard/Library/GetFunctionsDownloadCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Library } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetFunctionsDownloadCount',
+  description: 'Gets the total number of function downloads.',
+  apiResponse: true,
+
+  async handle() {
+    // return Library.functionsDownloadCount()
+  },
+})

package/app/Actions/Dashboard/Library/GetReleaseCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Library } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetReleaseCount',
+  description: 'Gets the total number of releases of your library.',
+  apiResponse: true,
+
+  async handle() {
+    // return Library.releaseCount()
+  },
+})

package/app/Actions/Dashboard/Library/GetReleases.ts

@@ -0,0 +1,28 @@
+import { Action } from '@stacksjs/actions'
+import { Release } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetReleases',
+  description: 'Gets your releases.',
+  method: 'GET',
+
+  async handle() {
+    try {
+      const allReleases = await Release.orderByDesc('id').get()
+
+      const releases = allReleases.map(r => ({
+        version: String(r.get('version') || ''),
+        date: String(r.get('created_at') || r.get('released_at') || ''),
+        type: String(r.get('type') || 'patch'),
+        status: String(r.get('status') || 'previous'),
+        changes: Number(r.get('changes') || r.get('change_count') || 0),
+        breaking: Boolean(r.get('breaking') || false),
+      }))
+
+      return { releases }
+    }
+    catch {
+      return { releases: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/Library/PackageIndexAction.ts

@@ -0,0 +1,26 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'PackageIndexAction',
+  description: 'Returns package data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const packages = [
+      { name: '@stacksjs/core', version: '2.4.0', latest: '2.4.0', type: 'dependency', status: 'up-to-date' },
+      { name: '@stacksjs/ui', version: '1.8.2', latest: '1.9.0', type: 'dependency', status: 'update-available' },
+      { name: '@stacksjs/database', version: '3.1.0', latest: '3.1.0', type: 'dependency', status: 'up-to-date' },
+      { name: 'typescript', version: '5.3.3', latest: '5.3.3', type: 'devDependency', status: 'up-to-date' },
+      { name: 'bun', version: '1.0.21', latest: '1.0.25', type: 'devDependency', status: 'update-available' },
+      { name: 'vitest', version: '1.1.0', latest: '1.2.0', type: 'devDependency', status: 'update-available' },
+    ]
+
+    const stats = [
+      { label: 'Total Packages', value: '47' },
+      { label: 'Up to Date', value: '41' },
+      { label: 'Updates Available', value: '6' },
+      { label: 'Security Issues', value: '0' },
+    ]
+
+    return { packages, stats }
+  },
+})

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

@@ -0,0 +1,45 @@
+import { Action } from '@stacksjs/actions'
+import { Campaign } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'CampaignIndexAction',
+  description: 'Returns marketing campaign data for the dashboard.',
+  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')}` : '-',
+      }))
+
+      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: '-' },
+      ]
+
+      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: '-' },
+        ],
+      }
+    }
+  },
+})

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

@@ -0,0 +1,43 @@
+import { Action } from '@stacksjs/actions'
+import { EmailList } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'ListIndexAction',
+  description: 'Returns mailing list data for the dashboard.',
+  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') || '-'),
+      }))
+
+      const totalSubscribers = lists.reduce((s, l) => s + l.members, 0)
+
+      const stats = [
+        { label: 'Total Subscribers', value: String(totalSubscribers) },
+        { label: 'New This Week', value: '-' },
+        { label: 'Unsubscribed', value: '-' },
+        { label: 'Avg Open Rate', value: '-' },
+      ]
+
+      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: '-' },
+        ],
+      }
+    }
+  },
+})

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

@@ -0,0 +1,47 @@
+import { Action } from '@stacksjs/actions'
+import { SocialPost } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'SocialPostIndexAction',
+  description: 'Returns social media post data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const platforms = ['All', 'Twitter', 'LinkedIn', 'Instagram', 'Facebook']
+
+    try {
+      const allPosts = await SocialPost.orderByDesc('id').get()
+
+      const posts = allPosts.map(p => ({
+        platform: String(p.get('platform') || ''),
+        content: String(p.get('content') || p.get('body') || ''),
+        status: String(p.get('status') || 'draft'),
+        engagement: String(p.get('engagement') || p.get('engagement_count') || '-'),
+        scheduled: String(p.get('scheduled_at') || p.get('published_at') || '-'),
+      }))
+
+      const scheduledCount = posts.filter(p => p.status === 'scheduled').length
+      const draftCount = posts.filter(p => p.status === 'draft').length
+
+      const stats = [
+        { label: 'Total Reach', value: '-' },
+        { label: 'Engagement', value: '-' },
+        { label: 'Scheduled', value: String(scheduledCount) },
+        { label: 'Drafts', value: String(draftCount) },
+      ]
+
+      return { posts, stats, platforms }
+    }
+    catch {
+      return {
+        posts: [],
+        stats: [
+          { label: 'Total Reach', value: '-' },
+          { label: 'Engagement', value: '-' },
+          { label: 'Scheduled', value: '0' },
+          { label: 'Drafts', value: '0' },
+        ],
+        platforms,
+      }
+    }
+  },
+})

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

@@ -0,0 +1,39 @@
+import type { Model } from '@stacksjs/types'
+import { Glob } from 'bun'
+import { Action } from '@stacksjs/actions'
+import { path } from '@stacksjs/path'
+
+export default new Action({
+  name: 'GetModels',
+  description: 'Gets the application models.',
+
+  async handle() {
+    const glob = new Glob('**/*.ts')
+    const scanOptions = { cwd: path.userModelsPath(), onlyFiles: true }
+    const displayModels: Model[] = []
+
+    for await (const file of glob.scan(scanOptions)) {
+      const model = (await import(path.userModelsPath(file))).default as Model
+      if (model.dashboard?.highlight !== undefined && model.dashboard?.highlight !== false)
+        displayModels.push(model)
+    }
+
+    if (!displayModels.length) {
+      // If no models should be highlighted, we can just return up to 8 models in alphabetical order
+      for await (const file of glob.scan(scanOptions)) {
+        const model = (await import(path.userModelsPath(file))).default as Model
+        displayModels.push(model)
+      }
+    }
+
+    if (displayModels.length > 8)
+      displayModels.length = 8
+    displayModels.sort((a, b) => (a.name || '').localeCompare(b.name || ''))
+
+    return displayModels.map(model => ({
+      model: model.name,
+      // TODO: implement this total logic
+      total: Math.floor(Math.random() * (999 - 10 + 1)) + 10,
+    }))
+  },
+})

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

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Subscriber } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetSubscriberCount',
+  description: 'Gets the total number of subscribers.',
+  apiResponse: true,
+
+  async handle() {
+    // return Subscriber.count()
+  },
+})

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

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+import { User } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetUserCount',
+  description: 'Gets the total number of users.',
+  apiResponse: true,
+
+  async handle() {
+    return User.count()
+  },
+})