deepspace 0.3.9 → 0.3.11

package/features/tasks/src/tasks-schema.ts

@@ -0,0 +1,56 @@
+/**
+ * Tasks/Challenges Feature - Schema
+ *
+ * A claimable task system demonstrating:
+ * - 'unclaimed-or-own' permission for claiming unclaimed items
+ * - writableFields for restricting which fields users can update
+ * - timestampTrigger for automatic timestamp fields
+ * - Admin-only grading workflow
+ */
+
+import type { CollectionSchema } from 'deepspace/worker'
+
+export const challengesSchema: CollectionSchema = {
+  name: 'challenges',
+  columns: [
+    { name: 'title', storage: 'text', interpretation: 'plain', required: true },
+    { name: 'description', storage: 'text', interpretation: 'plain', required: true },
+    { name: 'difficulty', storage: 'text', interpretation: 'plain', default: 'medium' },
+    { name: 'points', storage: 'number', interpretation: 'plain', default: 10 },
+    // Claim fields
+    { name: 'claimedById', storage: 'text', interpretation: 'plain' },
+    { name: 'claimedAt', storage: 'text', interpretation: 'plain', timestampTrigger: { field: 'claimedById' } },
+    // Submission fields
+    { name: 'submitted', storage: 'number', interpretation: { kind: 'boolean' }, default: false },
+    { name: 'submissionUrl', storage: 'text', interpretation: 'plain' },
+    { name: 'submissionNotes', storage: 'text', interpretation: 'plain' },
+    { name: 'submittedAt', storage: 'text', interpretation: 'plain', timestampTrigger: { field: 'submitted', value: true } },
+    // Grading fields (admin only)
+    { name: 'grade', storage: 'text', interpretation: 'plain' },
+    { name: 'feedback', storage: 'text', interpretation: 'plain' },
+    { name: 'gradedById', storage: 'text', interpretation: 'plain' },
+    { name: 'gradedAt', storage: 'text', interpretation: 'plain', timestampTrigger: { field: 'grade' } },
+    // Creator
+    { name: 'createdById', storage: 'text', interpretation: 'plain', required: true, userBound: true, immutable: true },
+  ],
+  ownerField: 'claimedById',
+  permissions: {
+    viewer: {
+      read: true,
+      create: false,
+      update: false,
+      delete: false,
+    },
+    member: {
+      read: true,
+      create: true,
+      update: 'unclaimed-or-own',
+      delete: 'own',
+      writableFields: [
+        'claimedById',
+        'submitted', 'submissionUrl', 'submissionNotes',
+      ],
+    },
+    admin: { read: true, create: true, update: true, delete: true },
+  },
+}

package/features/testing/feature.json

@@ -0,0 +1,49 @@
+{
+  "id": "testing",
+  "name": "Testing",
+  "category": "data",
+  "description": "E2E test page exercising RBAC and CRUD against RecordRoom",
+  "details": "Test infrastructure page used by Playwright e2e tests. Displays current role, creates/reads/updates/deletes test items, and verifies RBAC permission enforcement. Also installs cpu-burn and subrequest-burn server actions that intentionally exceed the dispatch worker's per-invocation limits — used by the e2e dispatch-limits spec to assert denial-of-wallet protection fires.",
+  "files": [
+    {
+      "src": "src/TestPage.tsx",
+      "dest": "src/pages/test.tsx"
+    },
+    {
+      "src": "src/test-schema.ts",
+      "dest": "src/schemas/test-schema.ts"
+    },
+    {
+      "src": "src/cpu-burn-action.ts",
+      "dest": "src/actions/cpu-burn.ts"
+    },
+    {
+      "src": "src/subrequest-burn-action.ts",
+      "dest": "src/actions/subrequest-burn.ts"
+    }
+  ],
+  "schema": {
+    "exportName": "testItemsSchema",
+    "importPath": "./schemas/test-schema",
+    "spreadOperator": false
+  },
+  "actions": [
+    {
+      "exportName": "cpuBurnAction",
+      "registerAs": "cpu-burn",
+      "importPath": "./cpu-burn"
+    },
+    {
+      "exportName": "subrequestBurnAction",
+      "registerAs": "subrequest-burn",
+      "importPath": "./subrequest-burn"
+    }
+  ],
+  "route": {
+    "path": "/test",
+    "protected": false
+  },
+  "requires": [],
+  "instructions": [],
+  "patterns": []
+}

package/features/testing/src/TestPage.tsx

@@ -0,0 +1,145 @@
+/**
+ * TestPage — exercises RBAC and CRUD against the RecordRoom.
+ *
+ * Used by Playwright e2e tests to verify real data flow.
+ * Displays current role, creates/reads/updates/deletes items.
+ */
+
+import { useState } from 'react'
+import { useQuery } from 'deepspace'
+import { useMutations } from 'deepspace'
+import { useUser } from 'deepspace'
+import { useRecordContext } from 'deepspace'
+import { useAuth } from 'deepspace'
+
+interface ItemData {
+  title: string
+  description: string
+  status: string
+  createdBy: string
+}
+
+export default function TestPage() {
+  const { isSignedIn } = useAuth()
+  const { user } = useUser()
+  const { roomRole } = useRecordContext()
+  const { records: items, status } = useQuery<ItemData>('test-items')
+  const isLoading = status === 'loading'
+  const { createConfirmed, putConfirmed, removeConfirmed } = useMutations<ItemData>('test-items')
+
+  const [lastResult, setLastResult] = useState<string>('')
+  const [lastError, setLastError] = useState<string>('')
+
+  const clearStatus = () => { setLastResult(''); setLastError('') }
+
+  const tryCreate = async () => {
+    clearStatus()
+    try {
+      const id = await createConfirmed({ title: 'Test Item', description: 'Created by test', status: 'draft', createdBy: user?.id ?? 'anonymous' })
+      setLastResult(`created:${id}`)
+    } catch (e: any) {
+      setLastError(e.message ?? String(e))
+    }
+  }
+
+  const tryCreatePublished = async () => {
+    clearStatus()
+    try {
+      const id = await createConfirmed({ title: 'Public Item', description: 'Visible to anonymous', status: 'published', createdBy: user?.id ?? 'anonymous' })
+      setLastResult(`created:${id}`)
+    } catch (e: any) {
+      setLastError(e.message ?? String(e))
+    }
+  }
+
+  const tryUpdate = async (recordId: string) => {
+    clearStatus()
+    try {
+      await putConfirmed(recordId, { title: 'Updated Title', description: 'Updated by test', status: 'draft', createdBy: user?.id ?? 'anonymous' })
+      setLastResult(`updated:${recordId}`)
+    } catch (e: any) {
+      setLastError(e.message ?? String(e))
+    }
+  }
+
+  const tryDelete = async (recordId: string) => {
+    clearStatus()
+    try {
+      await removeConfirmed(recordId)
+      setLastResult(`deleted:${recordId}`)
+    } catch (e: any) {
+      setLastError(e.message ?? String(e))
+    }
+  }
+
+  return (
+    <div className="mx-auto max-w-3xl p-8" data-testid="test-page">
+      <div className="mb-8 rounded-lg border border-border bg-card p-4">
+        <h2 className="text-lg font-semibold text-foreground mb-2">Connection Status</h2>
+        <div className="space-y-1 text-sm">
+          <div>Signed in: <span data-testid="test-signed-in">{String(isSignedIn)}</span></div>
+          <div>User ID: <span data-testid="test-user-id">{user?.id ?? 'none'}</span></div>
+          <div>Role: <span data-testid="test-user-role">{roomRole ?? 'connecting'}</span></div>
+          <div>User Name: <span data-testid="test-user-name">{user?.name ?? 'Anonymous'}</span></div>
+        </div>
+      </div>
+
+      <div className="mb-8 rounded-lg border border-border bg-card p-4">
+        <h2 className="text-lg font-semibold text-foreground mb-2">Actions</h2>
+        <div className="flex flex-wrap gap-2">
+          <button data-testid="test-create-item" onClick={tryCreate}
+            className="rounded bg-primary px-3 py-1.5 text-sm text-primary-foreground hover:opacity-90">
+            Create Draft Item
+          </button>
+          <button data-testid="test-create-published" onClick={tryCreatePublished}
+            className="rounded bg-primary px-3 py-1.5 text-sm text-primary-foreground hover:opacity-90">
+            Create Published Item
+          </button>
+        </div>
+        <div className="mt-3 min-h-[2.25rem]">
+          {lastResult && (
+            <div data-testid="test-last-result" className="rounded bg-success/20 px-3 py-2 text-sm text-success">
+              {lastResult}
+            </div>
+          )}
+          {lastError && (
+            <div data-testid="test-last-error" className="rounded bg-destructive/20 px-3 py-2 text-sm text-destructive">
+              {lastError}
+            </div>
+          )}
+        </div>
+      </div>
+
+      <div className="rounded-lg border border-border bg-card p-4">
+        <h2 className="text-lg font-semibold text-foreground mb-2">
+          Items {isLoading ? '(loading...)' : `(${items?.length ?? 0})`}
+        </h2>
+        <div data-testid="test-items-list" className="space-y-2">
+          {items?.map((item) => (
+            <div key={item.recordId} data-testid={`test-item-${item.recordId}`}
+              className="flex items-center justify-between rounded border border-border px-3 py-2">
+              <div className="text-sm">
+                <span className="font-medium text-foreground">{item.data.title}</span>
+                <span className="ml-2 text-muted-foreground">({item.data.status})</span>
+                <span className="ml-2 text-muted-foreground text-xs">by {item.data.createdBy}</span>
+              </div>
+              <div className="flex gap-1">
+                <button data-testid={`test-update-${item.recordId}`} onClick={() => tryUpdate(item.recordId)}
+                  className="rounded bg-secondary px-2 py-1 text-xs text-secondary-foreground hover:opacity-90">
+                  Update
+                </button>
+                <button data-testid={`test-delete-${item.recordId}`} onClick={() => tryDelete(item.recordId)}
+                  className="rounded bg-destructive/20 px-2 py-1 text-xs text-destructive hover:opacity-90">
+                  Delete
+                </button>
+              </div>
+            </div>
+          ))}
+          {!isLoading && (!items || items.length === 0) && (
+            <div data-testid="test-items-empty" className="text-sm text-muted-foreground">No items</div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

package/features/testing/src/cpu-burn-action.ts

@@ -0,0 +1,51 @@
+/**
+ * cpu-burn — server action that deliberately exceeds the dispatcher's
+ * CPU limit so the e2e `testing.spec.ts` can assert that
+ * `DEFAULT_LIMITS.cpuMs` on the dispatch worker actually fires.
+ *
+ * Runs a tight loop of hash computations until the runtime kills it. In
+ * production this would be a denial-of-wallet event; in the testing
+ * feature it's the whole point — we want the kill.
+ *
+ * The action returns only if CF *didn't* enforce the limit, which is
+ * itself a test failure signal (hence the misleading `success: true`
+ * — the spec asserts on the response status / outcome, not the body).
+ */
+
+import type { ActionHandler } from 'deepspace/worker'
+
+interface OwnerEnv {
+  OWNER_USER_ID?: string
+}
+
+export const cpuBurnAction: ActionHandler<OwnerEnv> = async (ctx) => {
+  // Owner-only: the whole point of this action is to deliberately blow
+  // the dispatcher's CPU cap, which burns real CF compute. Gate to the
+  // app owner so a random authenticated user can't weaponize every
+  // deployed app that installed the testing feature.
+  const ownerId = ctx.env.OWNER_USER_ID
+  if (ownerId && ctx.userId !== ownerId) {
+    return { success: false, error: 'Forbidden: owner only' }
+  }
+
+  // Keep the loop tight and work-generating so v8 can't eliminate it as
+  // dead code. Each iteration hashes a different value so the work
+  // isn't constant-foldable.
+  const encoder = new TextEncoder()
+  let counter = 0n
+  const deadline = Date.now() + 15_000 // safety: stop after 15s if CF didn't
+
+  while (Date.now() < deadline) {
+    const bytes = encoder.encode(`cpu-burn-${counter}`)
+    await crypto.subtle.digest('SHA-256', bytes)
+    counter += 1n
+  }
+
+  // If we got here, the dispatcher's limit did NOT fire — which is the
+  // thing the spec is checking against. Return a marker so the failure
+  // is diagnosable if the response ever makes it back.
+  return {
+    success: true,
+    data: { iterations: counter.toString(), note: 'limit-did-not-fire' },
+  }
+}

package/features/testing/src/subrequest-burn-action.ts

@@ -0,0 +1,53 @@
+/**
+ * subrequest-burn — server action that fires more outbound fetches than
+ * the dispatcher's `DEFAULT_LIMITS.subRequests` allows, so the e2e
+ * `testing.spec.ts` can assert the subRequests cap actually enforces.
+ *
+ * Hits the platform-worker health endpoint 60 times (cap is 50). The
+ * 51st subrequest should fail inside the user worker.
+ *
+ * Platform-worker is an internal service binding — no public network
+ * egress, no third-party rate-limit headaches.
+ */
+
+import type { ActionHandler } from 'deepspace/worker'
+
+interface OwnerEnv {
+  OWNER_USER_ID?: string
+}
+
+export const subrequestBurnAction: ActionHandler<OwnerEnv> = async (ctx) => {
+  // Owner-only — same reasoning as cpu-burn. Without this guard any
+  // authenticated user could force our dispatcher to emit 50 outbound
+  // fetches on command.
+  const ownerId = ctx.env.OWNER_USER_ID
+  if (ownerId && ctx.userId !== ownerId) {
+    return { success: false, error: 'Forbidden: owner only' }
+  }
+
+  // Target is an arbitrary URL — the test passes `https://example.com`
+  // but callers could point at an internal endpoint too. Fixed fallback
+  // so the spec works even when params aren't supplied.
+  const target = (ctx.params.target as string | undefined) ?? 'https://example.com'
+  const count = Math.max(1, Math.min(60, (ctx.params.count as number | undefined) ?? 60))
+
+  let completed = 0
+  let lastError: string | null = null
+  try {
+    for (let i = 0; i < count; i++) {
+      const res = await fetch(`${target}?i=${i}`, { method: 'GET' })
+      // Drain the body so the subrequest actually completes.
+      await res.arrayBuffer()
+      completed++
+    }
+  } catch (err) {
+    lastError = err instanceof Error ? err.message : String(err)
+  }
+
+  // If we completed all N subrequests, the cap didn't fire. Surface
+  // that as data so the spec can diagnose.
+  return {
+    success: completed === count,
+    data: { attempted: count, completed, lastError },
+  }
+}

package/features/testing/src/test-schema.ts

@@ -0,0 +1,23 @@
+/**
+ * Test Items Schema — exercises RBAC and CRUD for e2e testing.
+ */
+
+import type { CollectionSchema } from 'deepspace/worker'
+import { ROLE_ANONYMOUS } from 'deepspace/worker'
+
+export const testItemsSchema: CollectionSchema = {
+  name: 'test-items',
+  columns: [
+    { name: 'title', storage: 'text', interpretation: 'plain' },
+    { name: 'description', storage: 'text', interpretation: 'plain' },
+    { name: 'status', storage: 'text', interpretation: { kind: 'select', options: ['draft', 'published', 'archived'] } },
+    { name: 'createdBy', storage: 'text', interpretation: 'plain' },
+  ],
+  ownerField: 'createdBy',
+  permissions: {
+    [ROLE_ANONYMOUS]: { read: 'published', create: false, update: false, delete: false },
+    member: { read: true, create: true, update: 'own', delete: 'own' },
+    admin: { read: true, create: true, update: true, delete: true },
+  },
+  visibilityField: { field: 'status', value: 'published' },
+}

package/features/topbar/feature.json

@@ -0,0 +1,18 @@
+{
+  "id": "topbar",
+  "name": "Topbar",
+  "category": "nav",
+  "description": "Horizontal top navigation bar with search, user menu, and notifications",
+  "details": "Configurable top navigation bar component with logo/brand area, horizontal nav links with active state, optional search input, user avatar dropdown menu, and notification bell with badge count.",
+  "files": [
+    {
+      "src": "src/Topbar.tsx",
+      "dest": "src/components/topbar/Topbar.tsx"
+    }
+  ],
+  "requires": [],
+  "instructions": [
+    "Import Topbar into your layout and configure navItems, logo, and user props"
+  ],
+  "patterns": []
+}