@codewithagents/openapi-react-query 3.5.1 → 3.6.0

package/src/__tests__/config.test.ts

@@ -1,291 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { loadConfig, validateConfigPath, validateOutputPath, validateInputPath } from '../config.js'
-
-describe('loadConfig', () => {
-  let tmpDir: string
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'openapi-react-query-config-'))
-  })
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  function writeConfig(content: unknown) {
-    writeFileSync(join(tmpDir, 'openapi-react-query.config.json'), JSON.stringify(content))
-  }
-
-  it('loads a valid minimal config', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks' })
-    const config = await loadConfig(tmpDir)
-    expect(config.input_openapi).toBe('openapi.json')
-    expect(config.output).toBe('src/hooks')
-    expect(config.stale_time).toBeUndefined()
-    expect(config.gc_time).toBeUndefined()
-  })
-
-  it('loads a full config with all fields', async () => {
-    writeConfig({
-      input_openapi: 'api/openapi.json',
-      output: 'src/generated',
-      stale_time: 5000,
-      gc_time: 600000,
-    })
-    const config = await loadConfig(tmpDir)
-    expect(config.input_openapi).toBe('api/openapi.json')
-    expect(config.output).toBe('src/generated')
-    expect(config.stale_time).toBe(5000)
-    expect(config.gc_time).toBe(600000)
-  })
-
-  it('throws when config file is missing', async () => {
-    await expect(loadConfig(tmpDir)).rejects.toThrow('Config file not found')
-  })
-
-  it('throws when config is not valid JSON', async () => {
-    writeFileSync(join(tmpDir, 'openapi-react-query.config.json'), 'not json {{{')
-    await expect(loadConfig(tmpDir)).rejects.toThrow('not valid JSON')
-  })
-
-  it('throws when config is not an object', async () => {
-    writeFileSync(join(tmpDir, 'openapi-react-query.config.json'), '"just a string"')
-    await expect(loadConfig(tmpDir)).rejects.toThrow('JSON object')
-  })
-
-  it('throws when input_openapi is missing', async () => {
-    writeConfig({ output: 'src/hooks' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('input_openapi')
-  })
-
-  it('throws when output is missing', async () => {
-    writeConfig({ input_openapi: 'openapi.json' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('output')
-  })
-
-  it('throws when stale_time is not a number', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', stale_time: 'fast' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('stale_time')
-  })
-
-  it('throws when gc_time is not a number', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', gc_time: true })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('gc_time')
-  })
-
-  it('ignores unknown config fields', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', unknown_field: 'ignored' })
-    const config = await loadConfig(tmpDir)
-    expect(config.input_openapi).toBe('openapi.json')
-  })
-
-  it('accepts a config loaded via explicit configPath', async () => {
-    const configFile = join(tmpDir, 'custom.config.json')
-    writeFileSync(
-      configFile,
-      JSON.stringify({ input_openapi: 'openapi.json', output: 'src/hooks' })
-    )
-    const config = await loadConfig(tmpDir, configFile)
-    expect(config.input_openapi).toBe('openapi.json')
-    expect(config.output).toBe('src/hooks')
-  })
-
-  it('rejects explicit configPath that is not .json', async () => {
-    const configFile = join(tmpDir, 'config.ts')
-    writeFileSync(
-      configFile,
-      JSON.stringify({ input_openapi: 'openapi.json', output: 'src/hooks' })
-    )
-    await expect(loadConfig(tmpDir, configFile)).rejects.toThrow('Config file must be a .json file')
-  })
-
-  it('throws when suspense is not a boolean', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', suspense: 'yes' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"suspense" must be a boolean')
-  })
-
-  it('throws when auto_invalidate is not a boolean', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', auto_invalidate: 'yes' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"auto_invalidate" must be a boolean')
-  })
-
-  it('throws when overrides is not an object', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', overrides: 'flat' })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"overrides" must be an object')
-  })
-
-  it('throws when overrides is an array', async () => {
-    writeConfig({ input_openapi: 'openapi.json', output: 'src/hooks', overrides: [] })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"overrides" must be an object')
-  })
-
-  it('throws when an override entry is not an object', async () => {
-    writeConfig({
-      input_openapi: 'openapi.json',
-      output: 'src/hooks',
-      overrides: { pets: 'wrong' },
-    })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"overrides.pets" must be an object')
-  })
-
-  it('throws when override stale_time is not a number', async () => {
-    writeConfig({
-      input_openapi: 'openapi.json',
-      output: 'src/hooks',
-      overrides: { pets: { stale_time: 'fast' } },
-    })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"overrides.pets.stale_time" must be a number')
-  })
-
-  it('throws when override gc_time is not a number', async () => {
-    writeConfig({
-      input_openapi: 'openapi.json',
-      output: 'src/hooks',
-      overrides: { pets: { gc_time: true } },
-    })
-    await expect(loadConfig(tmpDir)).rejects.toThrow('"overrides.pets.gc_time" must be a number')
-  })
-
-  it('loads valid overrides', async () => {
-    writeConfig({
-      input_openapi: 'openapi.json',
-      output: 'src/hooks',
-      overrides: { pets: { stale_time: 1000, gc_time: 5000 } },
-    })
-    const config = await loadConfig(tmpDir)
-    expect(config.overrides).toEqual({ pets: { stale_time: 1000, gc_time: 5000 } })
-  })
-})
-
-describe('config security validation', () => {
-  describe('validateConfigPath', () => {
-    it('rejects non-.json config file extension', () => {
-      expect(() => validateConfigPath('/project/config.ts')).toThrow(
-        'Config file must be a .json file'
-      )
-    })
-
-    it('rejects .yaml extension', () => {
-      expect(() => validateConfigPath('/project/config.yaml')).toThrow(
-        'Config file must be a .json file'
-      )
-    })
-
-    it('accepts .json extension', () => {
-      expect(() => validateConfigPath('/project/config.json')).not.toThrow()
-    })
-
-    it('accepts nested .json path', () => {
-      expect(() => validateConfigPath('/Users/someone/project/my-tool.config.json')).not.toThrow()
-    })
-  })
-
-  describe('validateOutputPath', () => {
-    it('rejects output path in /etc', () => {
-      expect(() => validateOutputPath('/etc/generated')).toThrow('system directory')
-    })
-
-    it('rejects output path in /usr', () => {
-      expect(() => validateOutputPath('/usr/local/generated')).toThrow('system directory')
-    })
-
-    it('rejects output path in /bin', () => {
-      expect(() => validateOutputPath('/bin/generated')).toThrow('system directory')
-    })
-
-    it('rejects output path in /sys', () => {
-      expect(() => validateOutputPath('/sys/something')).toThrow('system directory')
-    })
-
-    it('rejects output path in /proc', () => {
-      expect(() => validateOutputPath('/proc/1/generated')).toThrow('system directory')
-    })
-
-    it('rejects output path in /dev', () => {
-      expect(() => validateOutputPath('/dev/null')).toThrow('system directory')
-    })
-
-    it('rejects output path in /boot', () => {
-      expect(() => validateOutputPath('/boot/generated')).toThrow('system directory')
-    })
-
-    it('rejects output path that is exactly /run', () => {
-      expect(() => validateOutputPath('/run')).toThrow('system directory')
-    })
-
-    it('rejects output path under /run/', () => {
-      expect(() => validateOutputPath('/run/lock/something')).toThrow('system directory')
-    })
-
-    it('does NOT reject /runner/_work/... (CI runner path)', () => {
-      expect(() => validateOutputPath('/runner/_work/project/src/generated')).not.toThrow()
-    })
-
-    it('accepts normal project-relative resolved path', () => {
-      expect(() => validateOutputPath('/Users/someone/project/generated')).not.toThrow()
-    })
-
-    it('accepts absolute path within home directory', () => {
-      expect(() => validateOutputPath('/Users/someone/myproject/src/hooks')).not.toThrow()
-    })
-
-    it('accepts dist/api style path', () => {
-      expect(() => validateOutputPath('/home/user/project/dist/hooks')).not.toThrow()
-    })
-
-    it('accepts GitHub Actions home runner output path', () => {
-      expect(() =>
-        validateOutputPath('/home/runner/work/my-repo/my-repo/src/generated')
-      ).not.toThrow()
-    })
-
-    it('accepts GitLab runner build output path', () => {
-      expect(() =>
-        validateOutputPath('/var/lib/gitlab-runner/builds/project/src/generated')
-      ).not.toThrow()
-    })
-
-    it('accepts common CI workspace output path', () => {
-      expect(() => validateOutputPath('/workspace/project/src/generated')).not.toThrow()
-    })
-  })
-
-  describe('validateInputPath', () => {
-    it('rejects input spec from /proc', () => {
-      expect(() => validateInputPath('/proc/1/fd/0')).toThrow('system directory')
-    })
-
-    it('rejects input spec from /etc', () => {
-      expect(() => validateInputPath('/etc/passwd')).toThrow('system directory')
-    })
-
-    it('rejects input spec from /dev', () => {
-      expect(() => validateInputPath('/dev/random')).toThrow('system directory')
-    })
-
-    it('rejects input spec from /usr', () => {
-      expect(() => validateInputPath('/usr/share/openapi.json')).toThrow('system directory')
-    })
-
-    it('accepts input spec in home directory', () => {
-      expect(() => validateInputPath('/Users/someone/project/openapi.json')).not.toThrow()
-    })
-
-    it('accepts input spec in /tmp', () => {
-      expect(() => validateInputPath('/tmp/openapi.json')).not.toThrow()
-    })
-
-    it('accepts GitHub Actions home runner input path', () => {
-      expect(() =>
-        validateInputPath('/home/runner/work/my-repo/my-repo/spec/api.json')
-      ).not.toThrow()
-    })
-
-    it('accepts common CI workspace input path', () => {
-      expect(() => validateInputPath('/workspace/project/spec/openapi.json')).not.toThrow()
-    })
-  })
-})

package/src/__tests__/hooks.property.test.ts

@@ -1,310 +0,0 @@
-import fc from 'fast-check'
-import { describe, expect, it } from 'vitest'
-import type { OpenAPIV3_1 } from 'openapi-types'
-import { generateHooks } from '../plugins/hooks.js'
-
-// ── Arbitrary generators ────────────────────────────────────────────────────
-
-/** Valid JS identifier: starts with letter, letters+digits, length 3–12 */
-const arbOperationId = fc.stringMatching(/^[a-z][a-zA-Z0-9]{2,11}$/)
-
-/** Valid JS identifier for path params: length 2–8 */
-const arbPathParam = fc.stringMatching(/^[a-z][a-z0-9]{1,7}$/)
-
-/** Query param object */
-const arbQueryParam = fc.record({
-  name: arbPathParam,
-  required: fc.boolean(),
-})
-
-/** Realistic resource names */
-const RESOURCES = [
-  'items',
-  'tasks',
-  'users',
-  'projects',
-  'orders',
-  'reports',
-  'documents',
-  'records',
-]
-
-/** Generates realistic path strings */
-const arbPath: fc.Arbitrary<string> = fc.oneof(
-  // /resources (no path params)
-  fc.constantFrom(...RESOURCES).map((r) => `/${r}`),
-  // /resources/{id} (1 path param)
-  fc.tuple(fc.constantFrom(...RESOURCES), arbPathParam).map(([r, p]) => `/${r}/{${p}}`),
-  // /resources/{p1}/sub/{p2} (2 path params)
-  fc
-    .tuple(fc.constantFrom(...RESOURCES), arbPathParam, fc.constantFrom(...RESOURCES), arbPathParam)
-    .map(([r, p1, sub, p2]) => `/${r}/{${p1}}/${sub}/{${p2}}`)
-)
-
-type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'
-
-const arbHttpMethod: fc.Arbitrary<HttpMethod> = fc.constantFrom(
-  'get',
-  'post',
-  'put',
-  'patch',
-  'delete'
-)
-
-function extractPathParams(path: string): string[] {
-  const matches = path.match(/\{([^}]+)\}/g)
-  if (matches === null) return []
-  return matches.map((m) => m.slice(1, -1))
-}
-
-interface ArbOp {
-  operationId: string
-  method: HttpMethod
-  path: string
-  pathParams: string[]
-  hasBody: boolean
-  queryParams: { name: string; required: boolean }[]
-}
-
-/** Generates a single operation object */
-const arbOperation: fc.Arbitrary<ArbOp> = fc
-  .tuple(
-    arbOperationId,
-    arbHttpMethod,
-    arbPath,
-    fc.array(arbQueryParam, { minLength: 0, maxLength: 3 })
-  )
-  .map(([operationId, method, path, queryParams]) => {
-    const pathParams = extractPathParams(path)
-    const hasBody = method === 'post' || method === 'put' || method === 'patch'
-    return { operationId, method, path, pathParams, hasBody, queryParams }
-  })
-
-/** Build a valid OpenAPI 3.1 document from ArbOp list */
-function buildSpec(ops: ArbOp[]): OpenAPIV3_1.Document {
-  const paths: OpenAPIV3_1.PathsObject = {}
-  for (const op of ops) {
-    if (!paths[op.path]) paths[op.path] = {}
-    const parameters = [
-      ...op.pathParams.map((p) => ({
-        name: p,
-        in: 'path' as const,
-        required: true,
-        schema: { type: 'string' as const },
-      })),
-      ...op.queryParams.map((q) => ({
-        name: q.name,
-        in: 'query' as const,
-        required: q.required,
-        schema: { type: 'string' as const },
-      })),
-    ]
-    ;(paths[op.path] as Record<string, unknown>)[op.method] = {
-      operationId: op.operationId,
-      parameters,
-      ...(op.hasBody
-        ? {
-            requestBody: {
-              required: true,
-              content: { 'application/json': { schema: { type: 'object' } } },
-            },
-          }
-        : {}),
-      responses: { '200': { description: 'ok' } },
-    }
-  }
-  return { openapi: '3.1.0', info: { title: 'Test', version: '1.0.0' }, paths }
-}
-
-/**
- * Generate a spec from 1–8 operations with unique operationIds.
- * Ensures no duplicate (path, method) pairs and unique operationIds.
- */
-const arbSpec: fc.Arbitrary<OpenAPIV3_1.Document> = fc
-  .array(arbOperation, { minLength: 1, maxLength: 8 })
-  .map((ops) => {
-    // Deduplicate by (path, method) — last one wins
-    const seen = new Map<string, ArbOp>()
-    for (const op of ops) {
-      seen.set(`${op.path}:${op.method}`, op)
-    }
-    const deduped = Array.from(seen.values())
-
-    // Make operationIds unique by appending index
-    const uniqueOps = deduped.map((op, i) => ({ ...op, operationId: `${op.operationId}${i}` }))
-    return buildSpec(uniqueOps)
-  })
-
-// ── Property tests ──────────────────────────────────────────────────────────
-
-describe('property-based tests — generateHooks invariants', () => {
-  // Property 1: generator never throws
-  it('never throws on any generated spec', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        expect(() => generateHooks(spec, { staleTime: 0, gcTime: 0 })).not.toThrow()
-      }),
-      { numRuns: 500 }
-    )
-  })
-
-  // Property 2: every GET produces a useQuery hook
-  it('every GET produces a useQuery hook named use + PascalCase(operationId)', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        for (const pathItem of Object.values(spec.paths ?? {})) {
-          const op = (pathItem as Record<string, unknown>)['get'] as
-            | { operationId?: string }
-            | undefined
-          if (!op?.operationId) continue
-          const hookName = 'use' + op.operationId[0]!.toUpperCase() + op.operationId.slice(1)
-          expect(content).toContain(`export function ${hookName}(`)
-        }
-      }),
-      { numRuns: 300 }
-    )
-  })
-
-  // Property 3: every mutation produces a useMutation hook
-  it('every POST/PUT/PATCH/DELETE produces a useMutation hook', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        for (const pathItem of Object.values(spec.paths ?? {})) {
-          for (const method of ['post', 'put', 'patch', 'delete'] as const) {
-            const op = (pathItem as Record<string, unknown>)[method] as
-              | { operationId?: string }
-              | undefined
-            if (!op?.operationId) continue
-            const hookName = 'use' + op.operationId[0]!.toUpperCase() + op.operationId.slice(1)
-            expect(content).toContain(`export function ${hookName}(`)
-          }
-        }
-      }),
-      { numRuns: 300 }
-    )
-  })
-
-  // Property 4: key factory always defines all() when any GET exists
-  // NOTE: The invariant checks for the definition `all:` in the key factory, not a call site `.all()`.
-  // A call to `.all()` only appears in mutation onSuccess handlers (autoInvalidate mode); a detail-only
-  // spec with no mutations correctly defines `all:` without ever calling it.
-  it('key factory defines all() method whenever there is at least one GET operation', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const hasGet = Object.values(spec.paths ?? {}).some(
-          (p) => (p as Record<string, unknown>)?.['get'] !== undefined
-        )
-        if (!hasGet) return // skip specs with no GET
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        // The key factory always includes an `all:` method definition
-        expect(content).toContain('all:')
-      }),
-      { numRuns: 300 }
-    )
-  })
-
-  // Property 5: hooks with 2+ path params always use && in enabled guard
-  it('detail hooks with 2+ path params use && in enabled guard', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        for (const [_path, pathItem] of Object.entries(spec.paths ?? {})) {
-          const op = (pathItem as Record<string, unknown>)['get'] as
-            | { operationId?: string; parameters?: Array<{ in: string }> }
-            | undefined
-          if (!op?.operationId) continue
-          const params = (op.parameters ?? []).filter((p) => p.in === 'path')
-          if (params.length < 2) continue
-          // The enabled guard should AND all params together
-          expect(content).toContain('&&')
-        }
-      }),
-      { numRuns: 200 }
-    )
-  })
-
-  // Property 6: with autoInvalidate, mutations only reference key factories that are generated.
-  // Previously buggy: the generator emitted `${resource}Keys.all()` even for mutation-only
-  // resources (no GET ops), producing a ReferenceError because the key factory was never defined.
-  // Fixed by gating invalidateInfo on resourceToGetOps.has(resource).
-  it('with autoInvalidate, mutation hooks only reference key factories that are generated', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, autoInvalidate: true })
-
-        // Collect all key factory names that ARE generated (only for resources with GET ops)
-        const resourcesWithGets = new Set<string>()
-        for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
-          const op = (pathItem as Record<string, unknown>)['get']
-          if (op === undefined) continue
-          // Extract primary resource (mirrors primaryResource() function)
-          const stripped = path.replace(/^\/api\/v\d+\//, '').replace(/^\//, '')
-          const firstSegment = (stripped.split('/')[0] ?? 'resource').replace(/[{}]/g, '')
-          resourcesWithGets.add(firstSegment)
-        }
-
-        // For each resource that appears in mutation ops but NOT in GET ops,
-        // a key factory reference in onSuccess is invalid (undefined reference)
-        for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
-          for (const method of ['post', 'put', 'patch', 'delete'] as const) {
-            const op = (pathItem as Record<string, unknown>)[method] as
-              | { operationId?: string }
-              | undefined
-            if (!op?.operationId) continue
-
-            const stripped = path.replace(/^\/api\/v\d+\//, '').replace(/^\//, '')
-            const firstSegment = (stripped.split('/')[0] ?? 'resource').replace(/[{}]/g, '')
-
-            if (!resourcesWithGets.has(firstSegment)) {
-              // This mutation is on a resource with no GET → generator will still emit
-              // `${factoryName}.all()` in the mutation hook, but the factory is never defined
-              const hookName = 'use' + op.operationId[0]!.toUpperCase() + op.operationId.slice(1)
-              const hookStart = content.indexOf(`export function ${hookName}(`)
-              if (hookStart === -1) continue
-              const hookEnd = content.indexOf('\n}', hookStart) + 2
-              const hookContent = content.slice(hookStart, hookEnd)
-
-              // The generated hook will reference factoryName (e.g. itemKeys)
-              // but that factory is never exported — check if the factory is defined
-              const camel = firstSegment.replace(/[-_](.)/g, (_: string, c: string) =>
-                c.toUpperCase()
-              )
-              const singular = camel.endsWith('s') ? camel.slice(0, -1) : camel
-              const factoryName = `${singular}Keys`
-
-              if (hookContent.includes(`${factoryName}.all()`)) {
-                // The key factory reference exists in the hook — verify the factory is exported
-                expect(content).toContain(`export const ${factoryName}`)
-              }
-            }
-          }
-        }
-      }),
-      { numRuns: 200 }
-    )
-  })
-
-  // Property 7: generated content always starts with the auto-generated header comment
-  it('generated output always starts with the auto-generated header comment', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        expect(content).toMatch(/^\/\/ (This file is auto-generated|Generated)/)
-      }),
-      { numRuns: 200 }
-    )
-  })
-
-  // Property 8: filename is always hooks.ts
-  it('filename is always hooks.ts', () => {
-    fc.assert(
-      fc.property(arbSpec, (spec) => {
-        const { filename } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-        expect(filename).toBe('hooks.ts')
-      }),
-      { numRuns: 100 }
-    )
-  })
-})