@sqaoss/flowy 1.3.0 → 1.4.0

package/src/commands/task.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from 'vitest'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
 
 vi.mock('../util/config.ts', () => ({
   requireFeature: vi.fn(() => {
@@ -18,10 +18,14 @@ vi.mock('../util/format.ts', () => ({
 }))
 
 describe('task command', () => {
-  test('exports a command group with 5 subcommands', async () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  test('exports a command group with 7 subcommands', async () => {
     const { taskCommand } = await import('./task.ts')
     expect(taskCommand.name()).toBe('task')
-    expect(taskCommand.commands).toHaveLength(5)
+    expect(taskCommand.commands).toHaveLength(7)
 
     const names = taskCommand.commands.map((c) => c.name())
     expect(names).toContain('create')
@@ -29,6 +33,16 @@ describe('task command', () => {
     expect(names).toContain('show')
     expect(names).toContain('block')
     expect(names).toContain('unblock')
+    expect(names).toContain('update')
+    expect(names).toContain('delete')
+  })
+
+  test('create exposes both --description and --description-file options', async () => {
+    const { taskCommand } = await import('./task.ts')
+    const createCmd = taskCommand.commands.find((c) => c.name() === 'create')!
+    const optionFlags = createCmd.options.map((o) => o.long)
+    expect(optionFlags).toContain('--description')
+    expect(optionFlags).toContain('--description-file')
   })
 
   test('create calls outputError when no active feature', async () => {
@@ -80,4 +94,165 @@ describe('task command', () => {
       }),
     )
   })
+
+  test('update sends updateNode with only the title when title-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1', title: 'New' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--title', 'New'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      { id: 'task_1', title: 'New' },
+    )
+    expect(output).toHaveBeenCalledWith({ id: 'task_1', title: 'New' })
+  })
+
+  test('update sends updateNode with only the description when description-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--description', 'Body'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        description: 'Body',
+      },
+    )
+  })
+
+  test('update sends updateNode with only the metadata when metadata-only', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_1', '--metadata', '{"k":"v"}'], {
+      from: 'user',
+    })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        metadata: '{"k":"v"}',
+      },
+    )
+  })
+
+  test('update sends updateNode with combined fields', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({
+      updateNode: { id: 'task_1' },
+    })
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(
+      ['task_1', '--title', 'New', '--description', 'Body', '--metadata', '{}'],
+      { from: 'user' },
+    )
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('updateNode'),
+      {
+        id: 'task_1',
+        title: 'New',
+        description: 'Body',
+        metadata: '{}',
+      },
+    )
+  })
+
+  test('update surfaces NOT_FOUND via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const notFound = Object.assign(new Error('Node task_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const updateCmd = taskCommand.commands.find((c) => c.name() === 'update')!
+    await updateCmd.parseAsync(['task_x', '--title', 'New'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'NOT_FOUND' }),
+    )
+  })
+
+  test('delete sends deleteNode mutation', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { output } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    vi.mocked(graphql).mockResolvedValueOnce({ deleteNode: true })
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_1'], { from: 'user' })
+
+    expect(graphql).toHaveBeenCalledWith(
+      expect.stringContaining('deleteNode'),
+      {
+        id: 'task_1',
+      },
+    )
+    expect(output).toHaveBeenCalledWith({ deleted: true })
+  })
+
+  test('delete surfaces CONFLICT via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const conflict = Object.assign(new Error('has children'), {
+      code: 'CONFLICT',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(conflict)
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_1'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'CONFLICT' }),
+    )
+  })
+
+  test('delete surfaces NOT_FOUND via outputError with its code', async () => {
+    const { graphql } = await import('../util/client.ts')
+    const { outputError } = await import('../util/format.ts')
+    const { taskCommand } = await import('./task.ts')
+
+    const notFound = Object.assign(new Error('Node task_x not found'), {
+      code: 'NOT_FOUND',
+    })
+    vi.mocked(graphql).mockRejectedValueOnce(notFound)
+
+    const deleteCmd = taskCommand.commands.find((c) => c.name() === 'delete')!
+    await deleteCmd.parseAsync(['task_x'], { from: 'user' })
+
+    expect(outputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'NOT_FOUND' }),
+    )
+  })
 })

package/src/commands/task.ts

@@ -12,14 +12,21 @@ taskCommand
   .command('create')
   .description('Create a task in the active feature')
   .requiredOption('--title <title>', 'Task title')
-  .requiredOption(
-    '--description <desc>',
-    'Task description (text or file path)',
+  .option(
+    '--description <text>',
+    'Task description, used verbatim (never read as a file path)',
+  )
+  .option(
+    '--description-file <path>',
+    'Read the task description from a file, or "-" for stdin',
   )
   .action(async (opts) => {
     try {
       const featureId = requireFeature()
-      const description = await resolveDescription(opts.description)
+      const description = await resolveDescription({
+        description: opts.description,
+        descriptionFile: opts.descriptionFile,
+      })
       const data = await graphql<{ createNode: { id: string } }>(
         `mutation CreateTask($type: String!, $title: String!, $description: String) {
           createNode(type: $type, title: $title, description: $description) {
@@ -86,6 +93,63 @@ taskCommand
     }
   })
 
+taskCommand
+  .command('update')
+  .description('Update a task')
+  .argument('<id>', 'Task ID')
+  .option('--title <title>', 'New title')
+  .option(
+    '--description <text>',
+    'New description, used verbatim (never read as a file path)',
+  )
+  .option(
+    '--description-file <path>',
+    'Read the new description from a file, or "-" for stdin',
+  )
+  .option('--metadata <json>', 'New metadata as a JSON string')
+  .action(async (id: string, opts) => {
+    try {
+      const variables: Record<string, unknown> = { id }
+      if (opts.title != null) variables.title = opts.title
+      if (opts.description != null || opts.descriptionFile != null) {
+        variables.description = await resolveDescription({
+          description: opts.description,
+          descriptionFile: opts.descriptionFile,
+        })
+      }
+      if (opts.metadata != null) variables.metadata = opts.metadata
+      const data = await graphql<{ updateNode: unknown }>(
+        `mutation UpdateNode($id: String!, $title: String, $description: String, $metadata: String) {
+          updateNode(id: $id, title: $title, description: $description, metadata: $metadata) {
+            id type title description status metadata createdAt updatedAt
+          }
+        }`,
+        variables,
+      )
+      output(data.updateNode)
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+taskCommand
+  .command('delete')
+  .description('Delete a task')
+  .argument('<id>', 'Task ID')
+  .action(async (id: string) => {
+    try {
+      const data = await graphql<{ deleteNode: boolean }>(
+        `mutation DeleteNode($id: String!) {
+          deleteNode(id: $id)
+        }`,
+        { id },
+      )
+      output({ deleted: data.deleteNode })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
 taskCommand
   .command('block')
   .description('Mark a task as blocking another')

package/src/index.test.ts

@@ -39,6 +39,9 @@ vi.mock('./commands/billing.ts', () => ({
 vi.mock('./commands/key.ts', () => ({
   keyCommand: { name: () => 'key' },
 }))
+vi.mock('./commands/serve.ts', () => ({
+  serveCommand: { name: () => 'serve' },
+}))
 
 describe('index.ts command registration', () => {
   test('registers billing and key commands', async () => {
@@ -57,4 +60,17 @@ describe('index.ts command registration', () => {
     expect(indexSource).toContain('program.addCommand(billingCommand)')
     expect(indexSource).toContain('program.addCommand(keyCommand)')
   })
+
+  test('registers the serve command', async () => {
+    const { readFileSync } = await import('node:fs')
+    const indexSource = readFileSync(
+      new URL('./index.ts', import.meta.url).pathname,
+      'utf-8',
+    )
+
+    expect(indexSource).toContain(
+      "import { serveCommand } from './commands/serve.ts'",
+    )
+    expect(indexSource).toContain('program.addCommand(serveCommand)')
+  })
 })

package/src/index.ts

@@ -19,6 +19,7 @@ import { initCommand } from './commands/init.ts'
 import { keyCommand } from './commands/key.ts'
 import { projectCommand } from './commands/project.ts'
 import { searchCommand } from './commands/search.ts'
+import { serveCommand } from './commands/serve.ts'
 import { setupCommand } from './commands/setup.ts'
 import { statusCommand } from './commands/status.ts'
 import { taskCommand } from './commands/task.ts'
@@ -32,6 +33,7 @@ const program = new Command()
 
 program.addCommand(initCommand)
 program.addCommand(setupCommand)
+program.addCommand(serveCommand)
 program.addCommand(clientCommand)
 program.addCommand(projectCommand)
 program.addCommand(featureCommand)

package/src/util/client.test.ts

@@ -1,5 +1,25 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
+function ok(json: unknown) {
+  return {
+    ok: true,
+    status: 200,
+    headers: { get: () => 'application/json' },
+    json: () => Promise.resolve(json),
+    text: () => Promise.resolve(JSON.stringify(json)),
+  }
+}
+
+function httpError(status: number, body = '<html>error</html>') {
+  return {
+    ok: false,
+    status,
+    headers: { get: () => 'text/html' },
+    json: () => Promise.reject(new SyntaxError('Unexpected token <')),
+    text: () => Promise.resolve(body),
+  }
+}
+
 beforeEach(() => {
   vi.doMock('./config.ts', () => ({
     getConfig: () => ({
@@ -18,12 +38,7 @@ describe('graphql client', () => {
   test('returns data on successful response', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            data: { whoami: { id: '1' } },
-          }),
-      }),
+      vi.fn().mockResolvedValue(ok({ data: { whoami: { id: '1' } } })),
     )
 
     const { graphql } = await import('./client.ts')
@@ -34,17 +49,16 @@ describe('graphql client', () => {
   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' },
-              },
-            ],
-          }),
-      }),
+      vi.fn().mockResolvedValue(
+        ok({
+          errors: [
+            {
+              message: 'Search query must be at least 3 characters',
+              extensions: { code: 'VALIDATION_ERROR' },
+            },
+          ],
+        }),
+      ),
     )
 
     const { graphql } = await import('./client.ts')
@@ -59,17 +73,16 @@ describe('graphql client', () => {
   test('throws original server message for unknown error codes', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            errors: [
-              {
-                message: 'Something broke',
-                extensions: { code: 'UNKNOWN_CODE' },
-              },
-            ],
-          }),
-      }),
+      vi.fn().mockResolvedValue(
+        ok({
+          errors: [
+            {
+              message: 'Something broke',
+              extensions: { code: 'UNKNOWN_CODE' },
+            },
+          ],
+        }),
+      ),
     )
 
     const { graphql } = await import('./client.ts')
@@ -81,12 +94,7 @@ describe('graphql client', () => {
   test('throws error message when extensions are absent', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            errors: [{ message: 'Auth required' }],
-          }),
-      }),
+      vi.fn().mockResolvedValue(ok({ errors: [{ message: 'Auth required' }] })),
     )
 
     const { graphql } = await import('./client.ts')
@@ -97,18 +105,12 @@ describe('graphql client', () => {
 
   test('omits Authorization header when no apiKey configured', async () => {
     vi.doMock('./config.ts', () => ({
-      getConfig: () => ({
-        apiUrl: 'http://test/graphql',
-        apiKey: '',
-      }),
+      getConfig: () => ({ apiUrl: 'http://test/graphql', apiKey: '' }),
     }))
 
-    const mockFetch = vi.fn().mockResolvedValue({
-      json: () =>
-        Promise.resolve({
-          data: { whoami: { id: '1' } },
-        }),
-    })
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValue(ok({ data: { whoami: { id: '1' } } }))
     vi.stubGlobal('fetch', mockFetch)
 
     const { graphql } = await import('./client.ts')
@@ -118,29 +120,30 @@ describe('graphql client', () => {
     expect(callHeaders).not.toHaveProperty('Authorization')
   })
 
-  test('throws on network error', async () => {
+  test('throws a NETWORK_ERROR-coded error on fetch rejection', async () => {
     vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('fetch failed')))
 
     const { graphql } = await import('./client.ts')
-    await expect(graphql('query { whoami { id } }')).rejects.toThrow(
-      'fetch failed',
-    )
+    await expect(
+      graphql('query { whoami { id } }', undefined, { retryDelayMs: 0 }),
+    ).rejects.toMatchObject({
+      code: 'NETWORK_ERROR',
+    })
   })
 
   test('throws friendly message for SUBSCRIPTION_REQUIRED error code', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            errors: [
-              {
-                message: 'Active subscription required.',
-                extensions: { code: 'SUBSCRIPTION_REQUIRED' },
-              },
-            ],
-          }),
-      }),
+      vi.fn().mockResolvedValue(
+        ok({
+          errors: [
+            {
+              message: 'Active subscription required.',
+              extensions: { code: 'SUBSCRIPTION_REQUIRED' },
+            },
+          ],
+        }),
+      ),
     )
 
     const { graphql } = await import('./client.ts')
@@ -152,17 +155,16 @@ describe('graphql client', () => {
   test('throws friendly message for SUBSCRIPTION_EXPIRED error code', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            errors: [
-              {
-                message: 'Subscription has expired.',
-                extensions: { code: 'SUBSCRIPTION_EXPIRED' },
-              },
-            ],
-          }),
-      }),
+      vi.fn().mockResolvedValue(
+        ok({
+          errors: [
+            {
+              message: 'Subscription has expired.',
+              extensions: { code: 'SUBSCRIPTION_EXPIRED' },
+            },
+          ],
+        }),
+      ),
     )
 
     const { graphql } = await import('./client.ts')
@@ -174,17 +176,16 @@ describe('graphql client', () => {
   test('throws friendly message for SUBSCRIPTION_SUSPENDED error code', async () => {
     vi.stubGlobal(
       'fetch',
-      vi.fn().mockResolvedValue({
-        json: () =>
-          Promise.resolve({
-            errors: [
-              {
-                message: 'Subscription is suspended.',
-                extensions: { code: 'SUBSCRIPTION_SUSPENDED' },
-              },
-            ],
-          }),
-      }),
+      vi.fn().mockResolvedValue(
+        ok({
+          errors: [
+            {
+              message: 'Subscription is suspended.',
+              extensions: { code: 'SUBSCRIPTION_SUSPENDED' },
+            },
+          ],
+        }),
+      ),
     )
 
     const { graphql } = await import('./client.ts')
@@ -192,4 +193,116 @@ describe('graphql client', () => {
       /suspended.*contact support/,
     )
   })
+
+  describe('transport hardening (F11)', () => {
+    test('throws a SERVER_ERROR-coded error on a non-retryable non-2xx (e.g. 500) without crashing on HTML body', async () => {
+      vi.stubGlobal('fetch', vi.fn().mockResolvedValue(httpError(500)))
+
+      const { graphql } = await import('./client.ts')
+      await expect(
+        graphql('query { whoami { id } }', undefined, { retryDelayMs: 0 }),
+      ).rejects.toMatchObject({ code: 'SERVER_ERROR' })
+      // Must surface a real message, not a raw SyntaxError about "<"
+      await expect(
+        graphql('query { whoami { id } }', undefined, { retryDelayMs: 0 }),
+      ).rejects.toThrow(/500/)
+    })
+
+    test('throws SERVER_ERROR (no crash) when a 200 body is not JSON', async () => {
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          status: 200,
+          headers: { get: () => 'text/html' },
+          json: () => Promise.reject(new SyntaxError('Unexpected token <')),
+          text: () => Promise.resolve('<html>proxy</html>'),
+        }),
+      )
+
+      const { graphql } = await import('./client.ts')
+      await expect(graphql('query { whoami { id } }')).rejects.toMatchObject({
+        code: 'SERVER_ERROR',
+      })
+    })
+
+    test('retries on a transient 429 then succeeds', async () => {
+      const mockFetch = vi
+        .fn()
+        .mockResolvedValueOnce(httpError(429))
+        .mockResolvedValueOnce(ok({ data: { whoami: { id: '1' } } }))
+      vi.stubGlobal('fetch', mockFetch)
+
+      const { graphql } = await import('./client.ts')
+      const result = await graphql('query { whoami { id } }', undefined, {
+        retryDelayMs: 0,
+      })
+      expect(result).toEqual({ whoami: { id: '1' } })
+      expect(mockFetch).toHaveBeenCalledTimes(2)
+    })
+
+    test('retries on 503 then gives up with a SERVER_ERROR-coded error', async () => {
+      const mockFetch = vi.fn().mockResolvedValue(httpError(503))
+      vi.stubGlobal('fetch', mockFetch)
+
+      const { graphql } = await import('./client.ts')
+      await expect(
+        graphql('query { whoami { id } }', undefined, {
+          retries: 2,
+          retryDelayMs: 0,
+        }),
+      ).rejects.toMatchObject({ code: 'SERVER_ERROR' })
+      // initial attempt + 2 retries = 3 calls
+      expect(mockFetch).toHaveBeenCalledTimes(3)
+    })
+
+    test('does NOT retry on a non-transient 400', async () => {
+      const mockFetch = vi.fn().mockResolvedValue(httpError(400))
+      vi.stubGlobal('fetch', mockFetch)
+
+      const { graphql } = await import('./client.ts')
+      await expect(
+        graphql('query { whoami { id } }', undefined, { retryDelayMs: 0 }),
+      ).rejects.toMatchObject({ code: 'SERVER_ERROR' })
+      expect(mockFetch).toHaveBeenCalledTimes(1)
+    })
+
+    test('aborts and throws NETWORK_ERROR on timeout', async () => {
+      const mockFetch = vi.fn().mockImplementation((_url, init) => {
+        return new Promise((_resolve, reject) => {
+          const signal = (init as { signal?: AbortSignal }).signal
+          signal?.addEventListener('abort', () => {
+            reject(
+              Object.assign(new Error('The operation was aborted'), {
+                name: 'AbortError',
+              }),
+            )
+          })
+        })
+      })
+      vi.stubGlobal('fetch', mockFetch)
+
+      const { graphql } = await import('./client.ts')
+      await expect(
+        graphql('query { whoami { id } }', undefined, {
+          timeoutMs: 10,
+          retries: 0,
+          retryDelayMs: 0,
+        }),
+      ).rejects.toMatchObject({ code: 'NETWORK_ERROR' })
+    })
+
+    test('passes a timeout signal to fetch', async () => {
+      const mockFetch = vi
+        .fn()
+        .mockResolvedValue(ok({ data: { whoami: { id: '1' } } }))
+      vi.stubGlobal('fetch', mockFetch)
+
+      const { graphql } = await import('./client.ts')
+      await graphql('query { whoami { id } }')
+
+      const init = mockFetch.mock.calls[0]![1]
+      expect(init.signal).toBeInstanceOf(AbortSignal)
+    })
+  })
 })