@sqaoss/flowy 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqaoss/flowy",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Agentic persistent planning",
   "type": "module",
   "bin": {
@@ -54,17 +54,17 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@semantic-release/changelog": "6.0.3",
-    "@semantic-release/git": "10.0.1",
-    "commander": "^14.0.3",
-    "semantic-release": "25.0.3"
+    "commander": "^14.0.3"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
     "@commitlint/cli": "^20.4.2",
     "@commitlint/config-conventional": "^20.4.2",
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/git": "10.0.1",
     "husky": "^9.1.7",
     "lint-staged": "^16.3.0",
+    "semantic-release": "25.0.3",
     "tdd-guard-vitest": "^0.1.6",
     "typescript": "^5",
     "vitest": "^4.1.2"

package/server/src/index.errors.test.ts

@@ -0,0 +1,97 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { createServer } from './index.ts'
+
+interface GraphQLResponse {
+  data?: unknown
+  errors?: Array<{ message: string; extensions?: { code?: string } }>
+}
+
+describe('server error masking', () => {
+  let instance: ReturnType<typeof createServer> | undefined
+
+  afterEach(() => {
+    instance?.close()
+    instance = undefined
+  })
+
+  async function gql(
+    query: string,
+    variables?: Record<string, unknown>,
+  ): Promise<GraphQLResponse> {
+    const res = await fetch(`http://localhost:${instance!.port}/graphql`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables }),
+    })
+    return (await res.json()) as GraphQLResponse
+  }
+
+  it('surfaces a too-short search error with real message and VALIDATION_ERROR code', async () => {
+    instance = createServer({ dbPath: ':memory:', port: 0 })
+
+    const json = await gql('query ($q: String!) { search(query: $q) { id } }', {
+      q: 'ab',
+    })
+
+    expect(json.errors).toBeDefined()
+    const error = json.errors![0]
+    expect(error.message).toBe('Search query must be at least 3 characters')
+    expect(error.message).not.toBe('Unexpected error.')
+    expect(error.extensions?.code).toBe('VALIDATION_ERROR')
+  })
+
+  it('surfaces a not-found update error with real message and NOT_FOUND code', async () => {
+    instance = createServer({ dbPath: ':memory:', port: 0 })
+
+    const json = await gql(
+      'mutation ($id: String!) { updateNode(id: $id, status: "done") { id } }',
+      { id: 'nonexistent' },
+    )
+
+    expect(json.errors).toBeDefined()
+    const error = json.errors![0]
+    expect(error.message).toBe('Node nonexistent not found')
+    expect(error.message).not.toBe('Unexpected error.')
+    expect(error.extensions?.code).toBe('NOT_FOUND')
+  })
+
+  it('surfaces an invalid-status error with real message and VALIDATION_ERROR code', async () => {
+    instance = createServer({ dbPath: ':memory:', port: 0 })
+
+    const created = (await gql(
+      'mutation { createNode(type: "task", title: "T") { id } }',
+    )) as { data: { createNode: { id: string } } }
+    const id = created.data.createNode.id
+
+    const json = await gql(
+      'mutation ($id: String!) { updateNode(id: $id, status: "bogus") { id } }',
+      { id },
+    )
+
+    expect(json.errors).toBeDefined()
+    const error = json.errors![0]
+    expect(error.message).toContain('Invalid status: bogus')
+    expect(error.message).not.toBe('Unexpected error.')
+    expect(error.extensions?.code).toBe('VALIDATION_ERROR')
+  })
+
+  it('surfaces an approve-wrong-status error with CONFLICT code', async () => {
+    instance = createServer({ dbPath: ':memory:', port: 0 })
+
+    const created = (await gql(
+      'mutation { createNode(type: "feature", title: "F") { id } }',
+    )) as { data: { createNode: { id: string } } }
+    const id = created.data.createNode.id
+
+    const json = await gql(
+      'mutation ($id: String!) { approveNode(id: $id) { id } }',
+      { id },
+    )
+
+    expect(json.errors).toBeDefined()
+    const error = json.errors![0]
+    expect(error.message).toContain('Cannot approve node with status "draft"')
+    expect(error.message).not.toBe('Unexpected error.')
+    expect(error.extensions?.code).toBe('CONFLICT')
+  })
+})

package/server/src/resolvers.ts

@@ -1,6 +1,21 @@
+import { createGraphQLError } from 'graphql-yoga'
 import { nanoid } from 'nanoid'
 import type { FlowyDb } from './db.ts'
 
+function validationError(message: string) {
+  return createGraphQLError(message, {
+    extensions: { code: 'VALIDATION_ERROR' },
+  })
+}
+
+function notFoundError(message: string) {
+  return createGraphQLError(message, { extensions: { code: 'NOT_FOUND' } })
+}
+
+function conflictError(message: string) {
+  return createGraphQLError(message, { extensions: { code: 'CONFLICT' } })
+}
+
 type Db = FlowyDb
 
 interface NodeRow {
@@ -163,7 +178,7 @@ export function createResolvers(db: Db) {
         },
       ) => {
         if (args.query.trim().length < 3) {
-          throw new Error('Search query must be at least 3 characters')
+          throw validationError('Search query must be at least 3 characters')
         }
         const escaped = args.query.replace(/[%_\\]/g, '\\$&')
         const conditions = [
@@ -193,9 +208,9 @@ export function createResolvers(db: Db) {
         _: unknown,
         args: { type: string; title: string; description?: string },
       ): NodeGql => {
-        if (!args.title.trim()) throw new Error('Title is required')
+        if (!args.title.trim()) throw validationError('Title is required')
         if (args.description != null && !args.description.trim()) {
-          throw new Error('Description cannot be empty')
+          throw validationError('Description cannot be empty')
         }
         const id = generateId(args.type)
         const now = new Date().toISOString()
@@ -220,10 +235,10 @@ export function createResolvers(db: Db) {
         const existing = db.raw
           .query('SELECT * FROM nodes WHERE id = ?')
           .get(args.id) as NodeRow | null
-        if (!existing) throw new Error(`Node ${args.id} not found`)
+        if (!existing) throw notFoundError(`Node ${args.id} not found`)
         const newStatus = args.status ?? existing.status
         if (args.status && !VALID_STATUSES.has(args.status)) {
-          throw new Error(
+          throw validationError(
             `Invalid status: ${args.status}. Must be one of: ${[...VALID_STATUSES].join(', ')}`,
           )
         }
@@ -240,9 +255,9 @@ export function createResolvers(db: Db) {
         const existing = db.raw
           .query('SELECT * FROM nodes WHERE id = ?')
           .get(args.id) as NodeRow | null
-        if (!existing) throw new Error(`Node ${args.id} not found`)
+        if (!existing) throw notFoundError(`Node ${args.id} not found`)
         if (existing.status !== 'pending_review') {
-          throw new Error(
+          throw conflictError(
             `Cannot approve node with status "${existing.status}", must be "pending_review"`,
           )
         }
@@ -261,7 +276,7 @@ export function createResolvers(db: Db) {
       ) => {
         const validRelations = new Set(['part_of', 'blocks'])
         if (!validRelations.has(args.relation)) {
-          throw new Error(
+          throw validationError(
             `Invalid relation: ${args.relation}. Must be 'part_of' or 'blocks'`,
           )
         }
@@ -269,16 +284,16 @@ export function createResolvers(db: Db) {
           .query('SELECT id FROM nodes WHERE id = ?')
           .get(args.sourceId)
         if (!sourceExists) {
-          throw new Error(`Source node ${args.sourceId} not found`)
+          throw notFoundError(`Source node ${args.sourceId} not found`)
         }
         const targetExists = db.raw
           .query('SELECT id FROM nodes WHERE id = ?')
           .get(args.targetId)
         if (!targetExists) {
-          throw new Error(`Target node ${args.targetId} not found`)
+          throw notFoundError(`Target node ${args.targetId} not found`)
         }
         if (args.relation === 'blocks' && args.sourceId === args.targetId) {
-          throw new Error('A node cannot block itself')
+          throw validationError('A node cannot block itself')
         }
         const now = new Date().toISOString()
         db.raw.run(

package/src/commands/project.ts

@@ -53,7 +53,7 @@ projectCommand
       )
       const project = data.nodes.find((n) => n.title === name)
       if (!project) {
-        throw new Error(`Project "${name}" not found`)
+        throw new Error(`Project "${name}" not found.`)
       }
       await setProject(project.id, project.title)
     } catch (error) {

package/src/util/client.test.ts

@@ -31,6 +31,31 @@ describe('graphql client', () => {
     expect(result).toEqual({ whoami: { id: '1' } })
   })
 
+  test('attaches extensions.code to the thrown error', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({
+        json: () =>
+          Promise.resolve({
+            errors: [
+              {
+                message: 'Search query must be at least 3 characters',
+                extensions: { code: 'VALIDATION_ERROR' },
+              },
+            ],
+          }),
+      }),
+    )
+
+    const { graphql } = await import('./client.ts')
+    await expect(
+      graphql('query { search(query: "ab") { id } }'),
+    ).rejects.toMatchObject({
+      message: 'Search query must be at least 3 characters',
+      code: 'VALIDATION_ERROR',
+    })
+  })
+
   test('throws original server message for unknown error codes', async () => {
     vi.stubGlobal(
       'fetch',

package/src/util/client.ts

@@ -47,7 +47,9 @@ export async function graphql<T = unknown>(
       )
     }
 
-    throw new Error(error?.message)
+    const err = new Error(error?.message) as Error & { code?: string }
+    if (code) err.code = code
+    throw err
   }
 
   return json.data as T

package/src/util/format.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { outputError } from './format.ts'
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('outputError', () => {
+  test('includes code in JSON when error has a code property', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
+
+    const err = Object.assign(
+      new Error('Search query must be at least 3 characters'),
+      { code: 'VALIDATION_ERROR' },
+    )
+    outputError(err)
+
+    expect(errorSpy).toHaveBeenCalledTimes(1)
+    const printed = JSON.parse(errorSpy.mock.calls[0]![0] as string)
+    expect(printed).toEqual({
+      error: 'Search query must be at least 3 characters',
+      code: 'VALIDATION_ERROR',
+    })
+  })
+
+  test('omits code when error has no code property', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
+
+    outputError(new Error('plain failure'))
+
+    const printed = JSON.parse(errorSpy.mock.calls[0]![0] as string)
+    expect(printed).toEqual({ error: 'plain failure' })
+    expect(printed).not.toHaveProperty('code')
+  })
+
+  test('exits with non-zero status', () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    const exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never)
+
+    outputError(new Error('boom'))
+
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})

package/src/util/format.ts

@@ -4,6 +4,11 @@ export function output(data: unknown): void {
 
 export function outputError(error: unknown): void {
   const message = error instanceof Error ? error.message : String(error)
-  console.error(JSON.stringify({ error: message }))
+  const rawCode =
+    error instanceof Error ? (error as { code?: unknown }).code : undefined
+  const code = typeof rawCode === 'string' ? rawCode : undefined
+  console.error(
+    JSON.stringify(code ? { error: message, code } : { error: message }),
+  )
   process.exit(1)
 }