@stacksjs/defaults 0.70.355 → 0.70.356

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

@@ -1,8 +1,8 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { env } from '@stacksjs/env'
 import { response as routerResponse } from '@stacksjs/router'
 import { loadModelIfExists, safeGet } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from '../dashboard-response'
 import { isValidModelSlug, type ModelCreateField, type ModelWriteCapabilities, modelCreateFields, modelSchemaColumns, modelWriteCapabilities, slugToPascal } from './model-write'
 
 /**
@@ -23,8 +23,8 @@ import { isValidModelSlug, type ModelCreateField, type ModelWriteCapabilities, m
  *      queries, so scopes, casts and accessors all apply.
  *   2. `loadModelIfExists(Name)` — path-map lookup, covers models the ORM has not
  *      registered as a global.
- *   3. Raw SQLite — last resort for a table with no model file at all
- *      (lookup/pivot tables, or a schema added outside the ORM).
+ * A missing model is a 404. The generic browser never bypasses model scopes,
+ * casts, observers, connection drivers, or the app override contract.
  */
 
 interface ColumnMeta {
@@ -50,8 +50,6 @@ interface ResponseShape {
   dir: 'asc' | 'desc'
   q: string
   filters: Record<string, string>
-  source: 'orm' | 'sqlite-fallback'
-  /** False for tables reached through the SQLite fallback: no model, no writes. */
   writable: boolean
   writeCapabilities: ModelWriteCapabilities
   createFields: ModelCreateField[]
@@ -85,6 +83,15 @@ function humanize(column: string): string {
 // filter by it.
 const HIDDEN_COLUMNS = new Set(['password', 'remember_token', 'api_token', 'access_token', 'refresh_token', 'secret', 'two_factor_secret'])
 
+function hiddenModelColumns(Model: any): Set<string> {
+  const hidden = new Set(HIDDEN_COLUMNS)
+  for (const [name, definition] of Object.entries(Model?.attributes ?? {})) {
+    if ((definition as { hidden?: boolean })?.hidden)
+      hidden.add(pascalToSnake(name))
+  }
+  return hidden
+}
+
 /**
  * Column identifiers reach the query builder as raw, unquoted SQL, so only
  * valid identifiers from the table's own column list may ever be used.
@@ -151,15 +158,6 @@ export function parseFilters(raw: string | null): Record<string, string> {
   return out
 }
 
-/**
- * Signals that a free-text search spans several columns, which the query
- * builder cannot express (`whereLike` is single-column and `orWhere` only
- * takes equality pairs). The SQLite path builds that OR with bound
- * parameters instead. Distinct from a real failure so it never surfaces
- * to the page as an error.
- */
-class SearchUnsupported extends Error {}
-
 function resolveOrmModel(modelName: string): any {
   const injected = (globalThis as Record<string, any>)[modelName]
   // The ORM injects Proxies that answer `undefined` for every property
@@ -213,182 +211,92 @@ export default new Action({
       dir,
       q,
       filters,
-      source: 'orm',
       writable: false,
       writeCapabilities: { create: false, update: false, destroy: false },
       createFields: [],
       error: null,
     }
 
-    const Model = resolveOrmModel(modelName) ?? await loadModelIfExists(modelName)
-    const hasOrm = Boolean(Model) && typeof Model.where === 'function'
-
-    if (hasOrm) {
-      try {
-        response.tableName = String(Model.table || tableName)
-        // The column list has to come from a real row: the ORM does not
-        // expose a database schema reflection API. Empty tables fall back
-        // to the model definition, which is also the migration source.
-        const probe = await Model.orderByDesc('id').take(1).get() as Array<Record<string, unknown>>
-        const first = Array.isArray(probe) ? probe[0] : undefined
-        const shape = first && typeof first === 'object'
-          ? ((first as { attributes?: Record<string, unknown> }).attributes ?? first)
-          : {}
-        response.columns = Object.keys(shape).filter(k => typeof k === 'string' && !k.startsWith('_'))
-        if (response.columns.length === 0)
-          response.columns = modelSchemaColumns(Model)
-
-        const allowed = new Set(response.columns.filter(c => !HIDDEN_COLUMNS.has(c)))
-        const unknownFilter = Object.keys(filters).find(column => !isSafeColumn(column, allowed))
-        if (unknownFilter)
-          return routerResponse.json({ message: `Unknown model filter column "${unknownFilter}".` }, 422)
-        if (requestedSort && !isSafeColumn(requestedSort, allowed))
-          return routerResponse.json({ message: `Unknown model sort column "${requestedSort}".` }, 422)
-
-        const sort = isSafeColumn(requestedSort, allowed)
-          ? requestedSort
-          : (allowed.has('id') ? 'id' : (response.columns[0] ?? ''))
-        response.sort = sort
-
-        // Text columns are decided from the probe row, before any query is
-        // built, so the search clause does not depend on response metadata
-        // that is only assembled after the rows come back.
-        const searchColumns = [...allowed].filter(c => typeof safeGet(first, c, null) === 'string')
-
-        const build = () => {
-          let chain = Model as any
-          for (const [column, value] of Object.entries(filters)) {
-            if (!isSafeColumn(column, allowed)) continue
-            chain = chain.where(column, value)
-          }
-          // Global search is a LIKE across every text column. The builder's
-          // `whereLike` covers one column and `orWhere` only takes equality
-          // pairs, so a multi-column OR-LIKE has no ORM expression; that
-          // case is served by the SQLite path below instead, which builds
-          // the OR with bound parameters. Writes stay enabled either way,
-          // because the model still exists.
-          if (q && searchColumns.length === 1)
-            chain = chain.whereLike(searchColumns[0], `%${q}%`)
-          return chain
-        }
-
-        // A multi-column search has no ORM expression, so hand that one
-        // query to the SQLite path — without recording an error, because it
-        // is a gap in the builder's vocabulary, not a failure.
-        if (q && searchColumns.length > 1)
-          throw new SearchUnsupported()
-
-        response.totalCount = q && searchColumns.length === 0
-          ? 0
-          : await build().count()
-        const rows = response.totalCount === 0
-          ? []
-          : await build()
-              .orderBy(sort, dir)
-              .skip((page - 1) * perPage)
-              .take(perPage)
-              .get() as Array<Record<string, unknown>>
-
-        // Flatten to plain JSON-safe objects — proxy models and
-        // accessor-rich rows do not serialise cleanly across the wire.
-        response.rows = (Array.isArray(rows) ? rows : []).map((row) => {
-          const flat: Record<string, unknown> = {}
-          for (const col of response.columns)
-            flat[col] = safeGet(row, col, null)
-          return flat
-        })
-      }
-      catch (e) {
-        if (e instanceof SearchUnsupported) {
-          response.source = 'sqlite-fallback'
-        }
-        else {
-          return routerResponse.json({
-            message: `Could not query model ${modelName}: ${e instanceof Error ? e.message : String(e)}`,
-          }, 503)
-        }
-      }
+    let Model: any
+    try {
+      Model = resolveOrmModel(modelName) ?? await loadModelIfExists(modelName)
     }
-    else {
-      response.source = 'sqlite-fallback'
+    catch (error) {
+      return dashboardOperationalError(error, `${modelName} could not be loaded.`, 'ModelShowAction.resolve')
     }
+    if (!Model || typeof Model.where !== 'function')
+      return routerResponse.json({ message: `No ORM model named ${modelName}.` }, 404)
 
-    if (response.source === 'sqlite-fallback') {
-      try {
-        const { Database } = await import('bun:sqlite')
-        const db = new Database(env.DB_DATABASE_PATH || 'database/stacks.sqlite', { readonly: true })
-        try {
-          if (!/^[A-Za-z_]\w*$/.test(response.tableName))
-            return routerResponse.json({ message: `Model table "${response.tableName}" is not a safe SQL identifier.` }, 500)
-
-          const tableInfo = db.query(`PRAGMA table_info(${response.tableName})`).all() as Array<{ name: string, type: string }>
-          if (tableInfo.length === 0)
-            return routerResponse.json({ message: `Model table "${response.tableName}" does not exist.` }, 404)
-
-          response.columns = tableInfo.map(c => c.name)
-
-          if (response.columns.length > 0) {
-            const allowed = new Set(response.columns.filter(c => !HIDDEN_COLUMNS.has(c)))
-            const unknownFilter = Object.keys(filters).find(column => !isSafeColumn(column, allowed))
-            if (unknownFilter)
-              return routerResponse.json({ message: `Unknown model filter column "${unknownFilter}".` }, 422)
-            if (requestedSort && !isSafeColumn(requestedSort, allowed))
-              return routerResponse.json({ message: `Unknown model sort column "${requestedSort}".` }, 422)
-
-            const sort = isSafeColumn(requestedSort, allowed)
-              ? requestedSort
-              : (allowed.has('id') ? 'id' : response.columns[0])
-            response.sort = sort
-
-            // Every value is bound; only identifiers are interpolated, and
-            // those come from the allowlist built out of PRAGMA above.
-            const wheres: string[] = []
-            const values: unknown[] = []
-            for (const [column, value] of Object.entries(filters)) {
-              if (!isSafeColumn(column, allowed)) continue
-              wheres.push(`${column} = ?`)
-              values.push(value)
-            }
-            if (q) {
-              const textColumns = tableInfo
-                .filter(c => allowed.has(c.name) && /char|text|clob/i.test(c.type || ''))
-                .map(c => c.name)
-              if (textColumns.length > 0) {
-                wheres.push(`(${textColumns.map(c => `${c} LIKE ?`).join(' OR ')})`)
-                for (const _ of textColumns) values.push(`%${q}%`)
-              }
-            }
-            const whereSql = wheres.length > 0 ? ` WHERE ${wheres.join(' AND ')}` : ''
-
-            const countRow = db.query(`SELECT COUNT(*) as count FROM ${response.tableName}${whereSql}`).get(...values as any[]) as { count?: number } | null
-            response.totalCount = countRow?.count ?? 0
-            response.rows = db
-              .query(`SELECT * FROM ${response.tableName}${whereSql} ORDER BY ${sort} ${dir.toUpperCase()} LIMIT ? OFFSET ?`)
-              .all(...values as any[], perPage, (page - 1) * perPage) as Array<Record<string, unknown>>
-            response.error = null
-          }
+    try {
+      response.tableName = String(Model.table || tableName)
+      const probe = await Model.orderByDesc('id').take(1).get() as Array<Record<string, unknown>>
+      const first = Array.isArray(probe) ? probe[0] : undefined
+      const shape = first && typeof first === 'object'
+        ? ((first as { attributes?: Record<string, unknown> }).attributes ?? first)
+        : {}
+      const hiddenColumns = hiddenModelColumns(Model)
+      response.columns = Object.keys(shape).filter(k => typeof k === 'string' && !k.startsWith('_') && !hiddenColumns.has(k))
+      if (response.columns.length === 0)
+        response.columns = modelSchemaColumns(Model).filter(column => !hiddenColumns.has(column))
+
+      const allowed = new Set(response.columns)
+      const unknownFilter = Object.keys(filters).find(column => !isSafeColumn(column, allowed))
+      if (unknownFilter)
+        return routerResponse.json({ message: `Unknown model filter column "${unknownFilter}".` }, 422)
+      if (requestedSort && !isSafeColumn(requestedSort, allowed))
+        return routerResponse.json({ message: `Unknown model sort column "${requestedSort}".` }, 422)
+
+      const sort = isSafeColumn(requestedSort, allowed)
+        ? requestedSort
+        : (allowed.has('id') ? 'id' : (response.columns[0] ?? ''))
+      response.sort = sort
+      const searchColumns = [...allowed].filter(c => typeof safeGet(first, c, null) === 'string')
+
+      const build = () => {
+        let chain = Model.query() as any
+        for (const [column, value] of Object.entries(filters)) {
+          if (!isSafeColumn(column, allowed)) continue
+          chain = chain.where(column, value)
         }
-        finally {
-          db.close()
+        if (q && searchColumns.length > 0) {
+          chain = chain.whereGroup((group: any) => {
+            for (const [index, column] of searchColumns.entries()) {
+              group = index === 0
+                ? group.whereLike(column, `%${q}%`)
+                : group.orWhereLike(column, `%${q}%`)
+            }
+            return group
+          })
         }
+        return chain
       }
-      catch (e) {
-        return routerResponse.json({
-          message: `Could not query table ${response.tableName}: ${e instanceof Error ? e.message : String(e)}`,
-        }, 503)
-      }
+
+      response.totalCount = q && searchColumns.length === 0
+        ? 0
+        : await build().count()
+      const rows = response.totalCount === 0
+        ? []
+        : await build()
+            .orderBy(sort, dir)
+            .skip((page - 1) * perPage)
+            .take(perPage)
+            .get() as Array<Record<string, unknown>>
+
+      response.rows = (Array.isArray(rows) ? rows : []).map((row) => {
+        const flat: Record<string, unknown> = {}
+        for (const col of response.columns)
+          flat[col] = safeGet(row, col, null)
+        return flat
+      })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, `${modelName} records could not be loaded.`, 'ModelShowAction.query')
     }
 
-    // Writability follows the model's declared useApi routes, not which
-    // engine answered this particular query. A multi-column search can be
-    // served by SQLite for a model that still creates and updates through
-    // the ORM.
-    response.writeCapabilities = hasOrm
-      ? modelWriteCapabilities(Model)
-      : { create: false, update: false, destroy: false }
+    response.writeCapabilities = modelWriteCapabilities(Model)
     response.writable = Object.values(response.writeCapabilities).some(Boolean)
     response.createFields = response.writeCapabilities.create ? modelCreateFields(Model) : []
-    response.displayColumns = response.columns.filter(col => !HIDDEN_COLUMNS.has(col) && !col.startsWith('_'))
+    response.displayColumns = response.columns.filter(col => !col.startsWith('_'))
     response.columnMeta = response.displayColumns.map(name => ({
       name,
       label: humanize(name),

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

@@ -1,6 +1,8 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { toSnakeCaseKeys } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 import { prepareModelFields, resolveWritableModel } from './model-write'
 
 interface ModelWriteInput {
@@ -15,7 +17,7 @@ export default new Action({
   async handle(request: RequestInstance<ModelWriteInput>) {
     const resolved = await resolveWritableModel(request.getParam('slug'), 'store')
     if ('error' in resolved)
-      return { ok: false, error: resolved.error }
+      return response.json({ message: resolved.error }, resolved.status)
 
     const input = request.all()
     const raw = input.fields
@@ -23,9 +25,9 @@ export default new Action({
     const { data, errors } = prepareModelFields(resolved.Model, body)
 
     if (Object.keys(errors).length > 0)
-      return { ok: false, error: 'Validation failed.', errors }
+      return response.json({ message: 'Validation failed.', errors }, 422)
     if (Object.keys(data).length === 0)
-      return { ok: false, error: 'No fillable fields in the request body.' }
+      return response.json({ message: 'No fillable fields in the request body.' }, 422)
 
     try {
       const row = await resolved.Model.create(toSnakeCaseKeys(data))
@@ -33,7 +35,7 @@ export default new Action({
       return { ok: true, id }
     }
     catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+      return dashboardOperationalError(error, 'The model record could not be created.', 'ModelStoreAction', 500)
     }
   },
 })

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

@@ -1,6 +1,8 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { toSnakeCaseKeys } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 import { parseRowId, prepareModelFields, resolveWritableModel } from './model-write'
 
 interface ModelWriteInput {
@@ -23,11 +25,11 @@ export default new Action({
   async handle(request: RequestInstance<ModelWriteInput>) {
     const resolved = await resolveWritableModel(request.getParam('slug'), 'update')
     if ('error' in resolved)
-      return { ok: false, error: resolved.error }
+      return response.json({ message: resolved.error }, resolved.status)
 
     const id = parseRowId(request.getParam('id'))
     if (id === null)
-      return { ok: false, error: 'A numeric row id is required.' }
+      return response.json({ message: 'A numeric row id is required.' }, 400)
 
     // Edits arrive nested under `fields`. The router's input bag merges the
     // body with route params and query, so a flat payload would silently
@@ -40,20 +42,20 @@ export default new Action({
     const body = (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw as Record<string, unknown> : {}
     const prepared = prepareModelFields(resolved.Model, body, true)
     if (Object.keys(prepared.errors).length > 0)
-      return { ok: false, error: 'Validation failed.', errors: prepared.errors }
+      return response.json({ message: 'Validation failed.', errors: prepared.errors }, 422)
     const changes = toSnakeCaseKeys(prepared.data)
     if (Object.keys(changes).length === 0)
-      return { ok: false, error: 'No writable fields in the request body.' }
+      return response.json({ message: 'No writable fields in the request body.' }, 422)
 
     try {
       const row = await resolved.Model.find(id)
       if (!row)
-        return { ok: false, error: `${resolved.modelName} ${id} not found.` }
+        return response.json({ message: `${resolved.modelName} ${id} not found.` }, 404)
       await resolved.Model.update(id, changes)
       return { ok: true, id, changed: Object.keys(changes) }
     }
-    catch (e) {
-      return { ok: false, error: e instanceof Error ? e.message : String(e) }
+    catch (error) {
+      return dashboardOperationalError(error, 'The model record could not be updated.', 'ModelUpdateAction', 500)
     }
   },
 })

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

@@ -3,6 +3,7 @@ import { existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import process from 'node:process'
 import { countRows } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError, dashboardOperationalIssue } from '../dashboard-response'
 import { modelApiConfiguration } from './model-api'
 
 /**
@@ -41,6 +42,12 @@ interface ModelGroup {
   countLabel: string
 }
 
+interface DiscoveredModel {
+  name: string
+  file: string
+  source: 'userland' | 'framework'
+}
+
 function pascalToSnake(s: string): string {
   return s.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
 }
@@ -92,6 +99,21 @@ function categoryLabel(k: string): string {
   return k === 'userland' ? 'Your Models' : k.charAt(0).toUpperCase() + k.slice(1)
 }
 
+function unavailableModelRow(model: DiscoveredModel, error: string): ModelRow {
+  return {
+    name: model.name,
+    table: pluralize(pascalToSnake(model.name)),
+    href: `/models/${pascalToKebab(model.name)}`,
+    count: null,
+    attributeCount: 0,
+    category: categorize(model),
+    source: model.source,
+    apiUri: '',
+    apiRoutes: [],
+    error,
+  }
+}
+
 export default new Action({
   name: 'Dashboard Models Index',
   description: 'List every model + live record count for the dashboard models overview.',
@@ -102,11 +124,18 @@ export default new Action({
     const userlandDir = join(cwd, 'app', 'Models')
     const defaultsDir = join(cwd, 'storage/framework/defaults/app/Models')
 
-    const userland = walkModels(userlandDir, false)
-    const defaults = walkModels(defaultsDir, true)
+    let userland: Array<Omit<DiscoveredModel, 'source'>>
+    let defaults: Array<Omit<DiscoveredModel, 'source'>>
+    try {
+      userland = walkModels(userlandDir, false)
+      defaults = walkModels(defaultsDir, true)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Model catalog could not be loaded.', 'ModelsIndexAction.catalog')
+    }
 
     const seen = new Set<string>()
-    const merged: Array<{ name: string, file: string, source: 'userland' | 'framework' }> = []
+    const merged: DiscoveredModel[] = []
     for (const list of [userland, defaults]) {
       for (const m of list) {
         if (seen.has(m.name)) continue
@@ -122,28 +151,29 @@ export default new Action({
         Model = module.default ?? module
       }
       catch (error) {
-        return {
-          name: m.name,
-          table: pluralize(pascalToSnake(m.name)),
-          href: `/models/${pascalToKebab(m.name)}`,
-          count: null,
-          attributeCount: 0,
-          category: categorize(m),
-          source: m.source,
-          apiUri: '',
-          apiRoutes: [],
-          error: error instanceof Error ? error.message : String(error),
-        }
+        return unavailableModelRow(
+          m,
+          dashboardOperationalIssue(error, 'Model definition could not be loaded.', `ModelsIndexAction.import.${m.name}`),
+        )
       }
 
-      const api = modelApiConfiguration(Model)
+      let api: ReturnType<typeof modelApiConfiguration>
+      try {
+        api = modelApiConfiguration(Model)
+      }
+      catch (error) {
+        return unavailableModelRow(
+          m,
+          dashboardOperationalIssue(error, 'Model metadata could not be loaded.', `ModelsIndexAction.metadata.${m.name}`),
+        )
+      }
       let count: number | null = null
       let error: string | null = null
       try {
         count = await countRows(Model)
       }
       catch (cause) {
-        error = cause instanceof Error ? cause.message : String(cause)
+        error = dashboardOperationalIssue(cause, 'Model count could not be loaded.', `ModelsIndexAction.count.${m.name}`)
       }
 
       return {

package/app/Actions/Dashboard/Models/model-write.ts

@@ -7,6 +7,7 @@
  * bypass every guarantee the ORM makes. Those rows stay read-only.
  */
 import { loadModelIfExists } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalIssue } from '../dashboard-response'
 import { modelApiConfiguration } from './model-api'
 
 /** Never writable from a generic admin table, whatever the model declares. */
@@ -42,6 +43,11 @@ export interface ResolvedModel {
   modelName: string
 }
 
+export interface ModelResolutionError {
+  error: string
+  status: 400 | 404 | 405 | 500
+}
+
 export type ModelWriteOperation = 'store' | 'update' | 'destroy'
 
 export interface ModelWriteCapabilities {
@@ -285,19 +291,28 @@ export function prepareModelFields(
  * injects (the same object the rest of the dashboard queries, so scopes,
  * casts and observers all apply) over the path-map lookup.
  */
-export async function resolveWritableModel(slug: string, operation?: ModelWriteOperation): Promise<ResolvedModel | { error: string }> {
+export async function resolveWritableModel(slug: string, operation?: ModelWriteOperation): Promise<ResolvedModel | ModelResolutionError> {
   if (!isValidModelSlug(slug))
-    return { error: 'Model slug must be lowercase kebab-case.' }
+    return { error: 'Model slug must be lowercase kebab-case.', status: 400 }
 
   const modelName = slugToPascal(slug)
   const injected = (globalThis as Record<string, any>)[modelName]
-  const Model = (injected && typeof injected.where === 'function') ? injected : await loadModelIfExists(modelName)
+  let Model: any
+  try {
+    Model = (injected && typeof injected.where === 'function') ? injected : await loadModelIfExists(modelName)
+  }
+  catch (error) {
+    return {
+      error: dashboardOperationalIssue(error, `${modelName} could not be loaded.`, `resolveWritableModel.${operation || 'read'}`),
+      status: 500,
+    }
+  }
   if (!Model || typeof Model.find !== 'function')
-    return { error: `No ORM model named ${modelName}. Rows from tables without a model are read-only.` }
+    return { error: `No ORM model named ${modelName}. Rows from tables without a model are read-only.`, status: 404 }
   if (operation) {
     const capability = operation === 'store' ? 'create' : operation
     if (!modelWriteCapabilities(Model)[capability])
-      return { error: `${modelName} does not declare the ${operation} route in its useApi trait.` }
+      return { error: `${modelName} does not declare the ${operation} route in its useApi trait.`, status: 405 }
   }
   return { Model, modelName }
 }