@stacksjs/defaults 0.74.3 → 0.74.5

package/app/Actions/Monitoring/error-provider.ts

@@ -0,0 +1,130 @@
+import type { DashboardProviderUnavailable } from '../Dashboard/dashboard-provider'
+import { errors } from '@stacksjs/commerce'
+import { HQ_READ_UNAVAILABLE, readThroughProvider, resolveDashboardDriver } from '../Dashboard/dashboard-provider'
+
+/**
+ * Where the Errors section reads from.
+ *
+ * Every one of these actions used to call `@stacksjs/commerce` directly, which
+ * is how error tracking came to be served by the shopping package: the store
+ * lives there for historical reasons and nine dashboard actions grew a
+ * dependency on it. Routing the reads through one provider puts that coupling
+ * in a single file, so replacing the store later is a change here rather than
+ * a change in nine actions.
+ *
+ * Read paths only. Resolving, ignoring, unresolving and deleting an error stay
+ * exactly where they were and always act on the local store. A section reading
+ * from a remote provider while writing to a local one would silently disagree
+ * with itself, so the write actions are deliberately left untouched until a
+ * provider exists that can actually accept a write.
+ */
+
+/**
+ * The record shapes the error store deals in.
+ *
+ * Derived from the store's own functions rather than imported, because
+ * `@stacksjs/commerce` exposes its errors module as a value and keeps these
+ * interfaces inside it. Deriving them means the provider contract follows the
+ * store automatically, and it keeps this refactor out of the commerce package.
+ */
+export type DashboardErrorRecord = NonNullable<Awaited<ReturnType<typeof errors.fetchById>>>
+export type DashboardGroupedError = Awaited<ReturnType<typeof errors.fetchGrouped>>[number]
+export type DashboardErrorStats = Awaited<ReturnType<typeof errors.fetchStats>>
+
+export interface DashboardErrorTimelinePoint {
+  hour: string
+  count: number
+}
+
+export interface DashboardErrorsProvider {
+  grouped: () => Promise<DashboardGroupedError[]>
+  stats: () => Promise<DashboardErrorStats>
+  timeline: () => Promise<DashboardErrorTimelinePoint[]>
+  byGroup: (type: string, message: string) => Promise<DashboardErrorRecord[]>
+  byId: (id: number) => Promise<DashboardErrorRecord | undefined>
+}
+
+/** Wraps a payload with the reason its section is empty. */
+export type DashboardErrorsEnvelope<T> = { data: T } & Partial<DashboardProviderUnavailable>
+
+/**
+ * This application's own error store.
+ *
+ * Not wrapped in a catch. These actions have never caught a store failure, and
+ * adding one here would convert today's error response into a misleading empty
+ * list, which is a behaviour change rather than the refactor this is meant to be.
+ */
+export const localErrorsProvider: DashboardErrorsProvider = {
+  grouped: () => errors.fetchGrouped(),
+  stats: () => errors.fetchStats(),
+  timeline: () => errors.fetchTimeline(),
+  byGroup: (type, message) => errors.fetchByGroup(type, message),
+  byId: id => errors.fetchById(id),
+}
+
+/**
+ * The empty answer for each read, used when a remote provider cannot be reached.
+ *
+ * `stats` has no natural empty value, so it reports zeros. A section showing
+ * zeros next to its reason is clearer than one showing nothing at all.
+ */
+const EMPTY_STATS: DashboardErrorStats = {
+  total: 0,
+  unresolved: 0,
+  resolved: 0,
+  ignored: 0,
+  last_24h: 0,
+  trend: 0,
+}
+
+async function resolveErrorsProvider(): Promise<{ provider: DashboardErrorsProvider, remote: boolean }> {
+  const driver = await resolveDashboardDriver('errors')
+  return { provider: localErrorsProvider, remote: driver.name !== 'local' }
+}
+
+/**
+ * Runs one error read through the configured provider.
+ *
+ * A local read is handed straight back, failures included. A remote read is
+ * guarded, so an unreachable provider yields the empty value plus a reason
+ * rather than taking the section down.
+ */
+async function readErrors<T>(
+  empty: T,
+  read: (provider: DashboardErrorsProvider) => Promise<T>,
+  isValid: (payload: unknown) => boolean,
+): Promise<DashboardErrorsEnvelope<T>> {
+  const { provider, remote } = await resolveErrorsProvider()
+
+  if (!remote)
+    return { data: await read(provider) }
+
+  const payload = await readThroughProvider<DashboardErrorsEnvelope<T>>(
+    'errors',
+    reason => ({ data: empty, unavailable: reason }),
+    async () => ({ data: empty, unavailable: HQ_READ_UNAVAILABLE }),
+    candidate => isValid((candidate as DashboardErrorsEnvelope<T>)?.data),
+  )
+
+  return payload
+}
+
+export function readGroupedErrors(): Promise<DashboardErrorsEnvelope<DashboardGroupedError[]>> {
+  return readErrors([], provider => provider.grouped(), Array.isArray)
+}
+
+export function readErrorStats(): Promise<DashboardErrorsEnvelope<DashboardErrorStats>> {
+  return readErrors(EMPTY_STATS, provider => provider.stats(), payload => Boolean(payload) && typeof payload === 'object')
+}
+
+export function readErrorTimeline(): Promise<DashboardErrorsEnvelope<DashboardErrorTimelinePoint[]>> {
+  return readErrors([], provider => provider.timeline(), Array.isArray)
+}
+
+export function readErrorsByGroup(type: string, message: string): Promise<DashboardErrorsEnvelope<DashboardErrorRecord[]>> {
+  return readErrors([], provider => provider.byGroup(type, message), Array.isArray)
+}
+
+export function readErrorById(id: number): Promise<DashboardErrorsEnvelope<DashboardErrorRecord | undefined>> {
+  return readErrors<DashboardErrorRecord | undefined>(undefined, provider => provider.byId(id), () => true)
+}

package/app/Models/EmailIdempotency.ts

@@ -17,7 +17,10 @@ export default defineModel({
     useApi: {
       uri: 'email-idempotency',
       routes: ['index', 'show', 'destroy'],
-      middleware: ['auth'],
+      // Reads stay as they were; writes need an admin.
+      // idempotency keys are what stop a retry from sending twice,
+      // so `auth` alone let any signed-in caller do it (stacksjs/stacks#2412).
+      middleware: { read: ['auth'], write: ['auth', 'role:admin'] },
     },
   },
 

package/app/Models/EmailSuppression.ts

@@ -25,7 +25,10 @@ export default defineModel({
     useApi: {
       uri: 'email-suppressions',
       routes: ['index', 'show', 'destroy'],
-      middleware: ['auth'],
+      // Reads stay as they were; writes need an admin.
+      // a suppression entry is a compliance record - deleting one re-enables mail to someone who bounced or opted out,
+      // so `auth` alone let any signed-in caller do it (stacksjs/stacks#2412).
+      middleware: { read: ['auth'], write: ['auth', 'role:admin'] },
     },
   },
 

package/app/Models/EmailWebhookEvent.ts

@@ -25,7 +25,10 @@ export default defineModel({
     useApi: {
       uri: 'email-webhook-events',
       routes: ['index', 'show', 'destroy'],
-      middleware: ['auth'],
+      // Reads stay as they were; writes need an admin.
+      // provider webhook events are the audit trail for what the provider told us,
+      // so `auth` alone let any signed-in caller do it (stacksjs/stacks#2412).
+      middleware: { read: ['auth'], write: ['auth', 'role:admin'] },
     },
   },
 

package/app/Models/Request.ts

@@ -36,7 +36,10 @@ export default defineModel({
     useApi: {
       uri: 'requests',
       routes: ['index', 'store', 'show', 'update', 'destroy'],
-      middleware: ['auth'],
+      // Reads stay as they were; writes need an admin.
+      // request logs are an audit trail, and carry whatever the request carried,
+      // so `auth` alone let any signed-in caller do it (stacksjs/stacks#2412).
+      middleware: { read: ['auth'], write: ['auth', 'role:admin'] },
     },
   },
 

package/functions/api-url.test.ts

@@ -0,0 +1,61 @@
+/**
+ * `resolveApiBaseUrl` must survive a `window` that is not a DOM.
+ *
+ * It guarded on `typeof window !== 'undefined'` and then read
+ * `window.location.origin`. Test harnesses assign `globalThis.window =
+ * globalThis` so browser code can be imported off-DOM, and that object has no
+ * `location` - so the guard passed and the next property read threw.
+ *
+ * Callers resolve this at MODULE scope (`monitoring/errors.ts` builds its
+ * `baseURL` there), so the throw happened on import: an unhandled error
+ * between tests, attributed to no test, which is why it survived a full-suite
+ * cleanup that fixed everything with a name (stacksjs/stacks#2421).
+ */
+import { afterEach, describe, expect, it } from 'bun:test'
+import { resolveApiBaseUrl } from './api-url'
+
+const REAL = {
+  window: (globalThis as any).window,
+  configured: (globalThis as any).__STACKS_API_URL__,
+}
+
+afterEach(() => {
+  for (const [key, value] of Object.entries({ window: REAL.window, __STACKS_API_URL__: REAL.configured })) {
+    if (value === undefined)
+      delete (globalThis as any)[key]
+    else
+      (globalThis as any)[key] = value
+  }
+})
+
+describe('resolveApiBaseUrl', () => {
+  it('falls back to the relative path when window has no location', () => {
+    // Exactly what a harness leaves behind: a window that is not a DOM.
+    ;(globalThis as any).window = globalThis
+    delete (globalThis as any).__STACKS_API_URL__
+
+    expect(resolveApiBaseUrl()).toBe('/api')
+  })
+
+  it('uses the origin when there is a real one', () => {
+    ;(globalThis as any).window = { location: { origin: 'https://app.test' } }
+    delete (globalThis as any).__STACKS_API_URL__
+
+    expect(resolveApiBaseUrl()).toBe('https://app.test/api')
+    expect(resolveApiBaseUrl('/v1')).toBe('https://app.test/v1')
+  })
+
+  it('prefers an injected URL over the origin, without its trailing slashes', () => {
+    ;(globalThis as any).window = { location: { origin: 'https://app.test' } }
+    ;(globalThis as any).__STACKS_API_URL__ = 'https://api.test//'
+
+    expect(resolveApiBaseUrl()).toBe('https://api.test')
+  })
+
+  it('falls back to the relative path off-DOM entirely', () => {
+    delete (globalThis as any).window
+    delete (globalThis as any).__STACKS_API_URL__
+
+    expect(resolveApiBaseUrl()).toBe('/api')
+  })
+})

package/functions/api-url.ts

@@ -15,8 +15,25 @@ export function resolveApiBaseUrl(defaultPath = '/api'): string {
   if (configured)
     return configured.replace(/\/+$/, '')
 
-  if (typeof window !== 'undefined')
-    return `${window.location.origin}${defaultPath}`
+  /*
+   * `window.location`, not just `window`.
+   *
+   * A global named `window` is not proof of a DOM. Test harnesses assign
+   * `globalThis.window = globalThis` to make browser code importable off-DOM,
+   * and that object has no `location` - so the guard passed and the very next
+   * property read threw `undefined is not an object`. Callers compute this at
+   * MODULE scope (`monitoring/errors.ts` builds its `baseURL` there), so the
+   * throw happened on import, before any code could catch it: it surfaced as an
+   * unhandled error between tests, attributed to no test at all
+   * (stacksjs/stacks#2421).
+   *
+   * Reading the origin defensively costs nothing in a real browser and keeps
+   * this resolvable anywhere - a worker, SSR, a partial DOM shim - where the
+   * honest answer is the relative default.
+   */
+  const origin = typeof window !== 'undefined' ? window.location?.origin : undefined
+  if (origin)
+    return `${origin}${defaultPath}`
 
   return defaultPath
 }

package/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.74.3",
+  "version": "0.74.5",
   "description": "A modern Stacks development environment.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.74.3",
+  "version": "0.74.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@iconify-json/f7": "^1.2.2",
     "@iconify-json/hugeicons": "^1.2.27",
-    "@stacksjs/mobile": "^0.74.3",
+    "@stacksjs/mobile": "^0.74.5",
     "@stacksjs/sanitizer": "^0.2.113",
     "ts-qr-codes": "^0.1.8"
   }