ts-procedures 6.1.0 → 6.2.0

package/src/codegen/targets/_shared/path-utils.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest'
+import { COLON_PARAM_RE, toBracePath, pathParamNames } from './path-utils.js'
+
+describe('path-utils', () => {
+  describe('toBracePath', () => {
+    it('converts colon params to brace form', () => {
+      expect(toBracePath('/users/:id')).toBe('/users/{id}')
+    })
+
+    it('converts multiple params', () => {
+      expect(toBracePath('/orgs/:orgId/users/:userId')).toBe('/orgs/{orgId}/users/{userId}')
+    })
+
+    it('returns the template unchanged when there are no params', () => {
+      expect(toBracePath('/users')).toBe('/users')
+    })
+
+    it('supports underscore-prefixed param names', () => {
+      expect(toBracePath('/x/:_id')).toBe('/x/{_id}')
+    })
+
+    it('does not match leading-digit identifiers', () => {
+      // ":1abc" is not a valid identifier; should not be rewritten.
+      expect(toBracePath('/x/:1abc')).toBe('/x/:1abc')
+    })
+  })
+
+  describe('pathParamNames', () => {
+    it('returns an empty list for templates without params', () => {
+      expect(pathParamNames('/users')).toEqual([])
+    })
+
+    it('returns the single param name', () => {
+      expect(pathParamNames('/users/:id')).toEqual(['id'])
+    })
+
+    it('preserves the order of multiple params', () => {
+      expect(pathParamNames('/orgs/:orgId/users/:userId')).toEqual(['orgId', 'userId'])
+    })
+
+    it('matches identifiers with digits and underscores', () => {
+      expect(pathParamNames('/x/:user_id1')).toEqual(['user_id1'])
+    })
+  })
+
+  describe('COLON_PARAM_RE', () => {
+    it('is a global regex (so matchAll works)', () => {
+      expect(COLON_PARAM_RE.global).toBe(true)
+    })
+  })
+})

package/src/codegen/targets/_shared/path-utils.ts

@@ -0,0 +1,21 @@
+/**
+ * Language-agnostic path-template utilities used by every codegen target that
+ * emits HTTP routes. Routes carry colon-prefixed path templates (e.g.
+ * `/users/:id`); targets typically need both the brace form (`/users/{id}`)
+ * for documentation/template constants and the parameter-name list for
+ * generating typed path-builder functions.
+ */
+
+export const COLON_PARAM_RE = /:([A-Za-z_][A-Za-z0-9_]*)/g
+
+/** Converts colon-prefixed path params (`:foo`) to brace form (`{foo}`). */
+export function toBracePath(template: string): string {
+  return template.replace(COLON_PARAM_RE, '{$1}')
+}
+
+/** Extracts the parameter names from a colon-prefixed path template. */
+export function pathParamNames(template: string): string[] {
+  const names: string[] = []
+  for (const match of template.matchAll(COLON_PARAM_RE)) names.push(match[1]!)
+  return names
+}

package/src/codegen/targets/_shared/pick-defined.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import { pickDefined } from './pick-defined.js'
+
+describe('pickDefined', () => {
+  it('returns only the keys whose values are not undefined', () => {
+    expect(
+      pickDefined(
+        { a: 1, b: undefined, c: 3 } as { a?: number; b?: number; c?: number },
+        ['a', 'b', 'c'],
+      ),
+    ).toEqual({ a: 1, c: 3 })
+  })
+
+  it('preserves the literal `false` value for boolean opts', () => {
+    expect(
+      pickDefined(
+        { depluralize: false, x: undefined } as { depluralize?: boolean; x?: number },
+        ['depluralize', 'x'],
+      ),
+    ).toEqual({ depluralize: false })
+  })
+
+  it('preserves the literal `false` for `string | false` opts (e.g. arrayItemNaming)', () => {
+    type Opts = { arrayItemNaming?: string | false }
+    const result = pickDefined<Opts, keyof Opts>({ arrayItemNaming: false }, ['arrayItemNaming'])
+    expect(result).toEqual({ arrayItemNaming: false })
+    expect('arrayItemNaming' in result).toBe(true)
+  })
+
+  it('omits keys not in the keys list even if they are defined on src', () => {
+    expect(
+      pickDefined({ a: 1, b: 2 } as { a?: number; b?: number }, ['a']),
+    ).toEqual({ a: 1 })
+  })
+
+  it('returns an empty object when all keys are undefined', () => {
+    expect(
+      pickDefined(
+        { a: undefined, b: undefined } as { a?: number; b?: number },
+        ['a', 'b'],
+      ),
+    ).toEqual({})
+  })
+
+  it('returns an empty object when keys is empty', () => {
+    expect(pickDefined({ a: 1 }, [] as never[])).toEqual({})
+  })
+})

package/src/codegen/targets/_shared/pick-defined.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns a new object containing only the keys of `src` whose values are
+ * not `undefined`. Useful for building option objects where unset keys must
+ * be ABSENT (not `undefined`-valued), so they don't shadow downstream
+ * defaults — e.g., when forwarding into a target's `Emit*Options`.
+ *
+ * @example
+ *   pickDefined({ a: 1, b: undefined, c: false }, ['a', 'b', 'c'])
+ *   // → { a: 1, c: false }
+ */
+export function pickDefined<T extends object, K extends keyof T>(
+  src: T,
+  keys: readonly K[],
+): Partial<Pick<T, K>> {
+  const out: Partial<Pick<T, K>> = {}
+  for (const key of keys) {
+    const value = src[key]
+    if (value !== undefined) {
+      out[key] = value
+    }
+  }
+  return out
+}

package/src/codegen/targets/_shared/route-slots.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { extractRouteSlots } from './route-slots.js'
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
+
+const r = (schema: Record<string, unknown> | undefined): AnyHttpRouteDoc =>
+  ({ name: 'X', kind: 'api', method: 'GET', fullPath: '/x', schema } as unknown as AnyHttpRouteDoc)
+
+describe('extractRouteSlots', () => {
+  it('returns no slots when schema is undefined', () => {
+    expect(extractRouteSlots(r(undefined))).toEqual([])
+  })
+
+  it('returns no slots when schema is empty', () => {
+    expect(extractRouteSlots(r({}))).toEqual([])
+  })
+
+  it('returns the deterministic slot order: PathParams, Query, Body, Response', () => {
+    const slots = extractRouteSlots(
+      r({
+        input: {
+          body: { type: 'object', x: 'body' },
+          query: { type: 'object', x: 'query' },
+          pathParams: { type: 'object', x: 'path' },
+        },
+        returnType: { type: 'object', x: 'response' },
+      }),
+    )
+    expect(slots.map((s) => s.rootName)).toEqual(['PathParams', 'Query', 'Body', 'Response'])
+  })
+
+  it('omits slots whose source is null or undefined', () => {
+    const slots = extractRouteSlots(
+      r({
+        input: { pathParams: { type: 'object' }, query: null, body: undefined },
+        // returnType missing
+      }),
+    )
+    expect(slots.map((s) => s.rootName)).toEqual(['PathParams'])
+  })
+
+  it('attaches the source schema verbatim to each slot', () => {
+    const path = { type: 'object', tag: 'p' }
+    const ret = { type: 'object', tag: 'r' }
+    const slots = extractRouteSlots(r({ input: { pathParams: path }, returnType: ret }))
+    expect(slots).toEqual([
+      { rootName: 'PathParams', source: path },
+      { rootName: 'Response', source: ret },
+    ])
+  })
+
+  it('returns no slots for stream/no-schema routes', () => {
+    const stream = { name: 'S', kind: 'stream', method: 'GET', path: '/s' } as unknown as AnyHttpRouteDoc
+    expect(extractRouteSlots(stream)).toEqual([])
+  })
+})

package/src/codegen/targets/_shared/route-slots.ts

@@ -0,0 +1,32 @@
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
+
+/**
+ * A "slot" is one of the deterministic schema sources a route exposes:
+ * `pathParams`, `query`, `body` (under `schema.input`) and the response
+ * (`schema.returnType`). Targets emit one type per non-null slot.
+ */
+export interface RouteSlot {
+  /** Stable identifier used as the emitted type's `rootTypeName`. */
+  rootName: string
+  /** The raw JSON Schema source for this slot, or `null`/`undefined` when absent. */
+  source: unknown
+}
+
+/**
+ * Returns the deterministic ordered slot list for a route, filtered to slots
+ * with non-null sources. Order is fixed at the module level for stable output.
+ */
+export function extractRouteSlots(route: AnyHttpRouteDoc): RouteSlot[] {
+  const schema = (route as { schema?: Record<string, unknown> }).schema ?? {}
+  const input = (schema.input ?? {}) as Record<string, unknown>
+
+  // Order is load-bearing: targets emit slots in this sequence.
+  const slots: RouteSlot[] = [
+    { rootName: 'PathParams', source: input.pathParams },
+    { rootName: 'Query', source: input.query },
+    { rootName: 'Body', source: input.body },
+    { rootName: 'Response', source: schema.returnType },
+  ]
+
+  return slots.filter((s) => s.source != null)
+}

package/src/codegen/targets/_shared/target-run.ts

@@ -0,0 +1,28 @@
+import type { DocEnvelope } from '../../../implementations/types.js'
+import type { ScopeGroup } from '../../group-routes.js'
+import type { AjscOptions } from '../../emit-types.js'
+
+/**
+ * Inputs the dispatcher prepares once and forwards to every per-target
+ * `run*Pipeline` module. Each target module reads only the fields it needs.
+ *
+ * The fields here are deliberately narrow: target-specific knobs (e.g.
+ * `kotlinPackage`, `swiftSerializer`) are passed as additional options on
+ * each per-target input shape, not on this base.
+ */
+export interface TargetRunInput {
+  envelope: DocEnvelope
+  outDir: string
+  /** MD5 hash of the envelope JSON, prefix-stamped into every emitted file. */
+  hash: string
+  /** Pre-grouped routes (one entry per scope key). */
+  groups: ScopeGroup[]
+  /** Validated service name (defaults to `Api` upstream). */
+  serviceName: string
+  ajsc?: AjscOptions
+  clientImportPath?: string
+  dryRun?: boolean
+  namespaceTypes?: boolean
+  selfContained?: boolean
+  cleanOutDir?: boolean
+}

package/src/codegen/targets/_shared/write-files.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { mkdir, readFile, rm, writeFile, stat, mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { writeGeneratedFiles } from './write-files.js'
+
+describe('writeGeneratedFiles', () => {
+  describe('dryRun mode', () => {
+    let logSpy: ReturnType<typeof vi.spyOn>
+
+    beforeEach(() => {
+      logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      logSpy.mockRestore()
+    })
+
+    it('logs each file with its byte length and does not touch the filesystem', async () => {
+      const dir = '/nonexistent/should-not-be-created'
+      await writeGeneratedFiles(
+        [
+          { path: `${dir}/a.txt`, code: 'hello' },
+          { path: `${dir}/b.txt`, code: 'hi' },
+        ],
+        dir,
+        { dryRun: true },
+      )
+      expect(logSpy).toHaveBeenCalledWith(`[dry-run] Would write: ${dir}/a.txt (5 bytes)`)
+      expect(logSpy).toHaveBeenCalledWith(`[dry-run] Would write: ${dir}/b.txt (2 bytes)`)
+      // Sanity: the dir was not created.
+      await expect(stat(dir)).rejects.toBeInstanceOf(Error)
+    })
+
+    it('logs a clean-outDir notice when cleanOutDir is true', async () => {
+      await writeGeneratedFiles([], '/out', { dryRun: true, cleanOutDir: true })
+      expect(logSpy).toHaveBeenCalledWith('[dry-run] Would clean outDir: /out')
+    })
+
+    it('does not log clean-outDir when cleanOutDir is false', async () => {
+      await writeGeneratedFiles([{ path: '/out/x', code: 'x' }], '/out', { dryRun: true })
+      const messages = logSpy.mock.calls.map((c: unknown[]) => c[0])
+      expect(messages.find((m: unknown) => String(m).includes('Would clean'))).toBeUndefined()
+    })
+
+    it('counts bytes as utf-8', async () => {
+      // "é" is 2 bytes in utf-8.
+      await writeGeneratedFiles([{ path: '/x/e.txt', code: 'é' }], '/x', { dryRun: true })
+      expect(logSpy).toHaveBeenCalledWith('[dry-run] Would write: /x/e.txt (2 bytes)')
+    })
+  })
+
+  describe('real write mode', () => {
+    let outDir: string
+
+    beforeEach(async () => {
+      outDir = await mkdtemp(join(tmpdir(), 'write-files-test-'))
+    })
+
+    afterEach(async () => {
+      await rm(outDir, { recursive: true, force: true })
+    })
+
+    it('writes each file with utf-8 contents', async () => {
+      await writeGeneratedFiles(
+        [
+          { path: join(outDir, 'a.txt'), code: 'alpha' },
+          { path: join(outDir, 'b.txt'), code: 'beta' },
+        ],
+        outDir,
+      )
+      expect(await readFile(join(outDir, 'a.txt'), 'utf-8')).toBe('alpha')
+      expect(await readFile(join(outDir, 'b.txt'), 'utf-8')).toBe('beta')
+    })
+
+    it('creates outDir recursively if missing', async () => {
+      const nested = join(outDir, 'a', 'b', 'c')
+      await writeGeneratedFiles([{ path: join(nested, 'x.txt'), code: 'x' }], nested)
+      expect(await readFile(join(nested, 'x.txt'), 'utf-8')).toBe('x')
+    })
+
+    it('removes outDir when cleanOutDir is true before writing', async () => {
+      // Pre-populate a stale file.
+      await mkdir(outDir, { recursive: true })
+      await writeFile(join(outDir, 'stale.txt'), 'stale', 'utf-8')
+
+      await writeGeneratedFiles(
+        [{ path: join(outDir, 'fresh.txt'), code: 'fresh' }],
+        outDir,
+        { cleanOutDir: true },
+      )
+
+      await expect(readFile(join(outDir, 'stale.txt'), 'utf-8')).rejects.toBeInstanceOf(Error)
+      expect(await readFile(join(outDir, 'fresh.txt'), 'utf-8')).toBe('fresh')
+    })
+
+    it('does not remove outDir when cleanOutDir is false', async () => {
+      await mkdir(outDir, { recursive: true })
+      await writeFile(join(outDir, 'keep.txt'), 'keep', 'utf-8')
+
+      await writeGeneratedFiles(
+        [{ path: join(outDir, 'new.txt'), code: 'new' }],
+        outDir,
+      )
+
+      expect(await readFile(join(outDir, 'keep.txt'), 'utf-8')).toBe('keep')
+      expect(await readFile(join(outDir, 'new.txt'), 'utf-8')).toBe('new')
+    })
+  })
+})

package/src/codegen/targets/_shared/write-files.ts

@@ -0,0 +1,53 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+
+export interface GeneratedFile {
+  path: string
+  code: string
+}
+
+export interface WriteOptions {
+  /** When true, log what would happen instead of touching the filesystem. */
+  dryRun?: boolean
+  /** When true, recursively delete `outDir` before writing. */
+  cleanOutDir?: boolean
+}
+
+/**
+ * Persists the generated files to disk (or simulates the writes under
+ * `dryRun`). Centralises the dryRun / cleanOutDir / mkdir / writeFile
+ * sequence shared by every codegen target so per-target run modules don't
+ * duplicate it.
+ *
+ * Behaviour:
+ * - `dryRun: true` — logs `[dry-run] Would write: <path> (<bytes> bytes)` per
+ *   file, plus a leading `[dry-run] Would clean outDir: <outDir>` when
+ *   `cleanOutDir: true`. No filesystem mutation.
+ * - `dryRun: false` (default) — when `cleanOutDir`, recursively removes
+ *   `outDir`; then ensures it exists; then writes each file as utf-8.
+ */
+export async function writeGeneratedFiles(
+  files: readonly GeneratedFile[],
+  outDir: string,
+  opts: WriteOptions = {},
+): Promise<void> {
+  const { dryRun = false, cleanOutDir = false } = opts
+
+  if (dryRun) {
+    if (cleanOutDir) {
+      console.log(`[dry-run] Would clean outDir: ${outDir}`)
+    }
+    for (const f of files) {
+      const bytes = Buffer.byteLength(f.code, 'utf-8')
+      console.log(`[dry-run] Would write: ${f.path} (${bytes} bytes)`)
+    }
+    return
+  }
+
+  if (cleanOutDir) {
+    await rm(outDir, { recursive: true, force: true })
+  }
+  await mkdir(outDir, { recursive: true })
+  for (const f of files) {
+    await writeFile(f.path, f.code, 'utf-8')
+  }
+}

package/src/codegen/targets/kotlin/e2e-compile.test.ts

@@ -47,7 +47,7 @@ describe('kotlin codegen — kotlinc compile (gated)', () => {
     async () => {
       const emitter = await resolveProductionKotlinEmitter()
       const envelope = JSON.parse(
-        readFileSync(join(__dirname, '__fixtures__/users-envelope.json'), 'utf8'),
+        readFileSync(join(__dirname, '../../__fixtures__/users-envelope.json'), 'utf8'),
       )
       const files = await runPipeline({
         envelope,

package/src/codegen/targets/kotlin/emit-route-kotlin.ts

@@ -1,6 +1,9 @@
 import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
 import type { KotlinEmitter, KotlinEmitOptions } from './ajsc-adapter.js'
-import { indent, pickDefined } from './format-kotlin.js'
+import { indent } from '../_shared/indent.js'
+import { pickDefined } from '../_shared/pick-defined.js'
+import { toBracePath, pathParamNames } from '../_shared/path-utils.js'
+import { extractRouteSlots } from '../_shared/route-slots.js'
 
 export interface EmitRouteResult {
   /** Inner body of the `object RouteName { ... }` block — already indented one level. */
@@ -16,18 +19,6 @@ export interface EmitRouteResult {
 /** Subset of KotlinEmitOptions threaded by the pipeline; per-call rootTypeName is set inside. */
 export type EmitRouteOpts = Omit<KotlinEmitOptions, 'rootTypeName' | 'inlineTypes'>
 
-const COLON_PARAM_RE = /:([A-Za-z_][A-Za-z0-9_]*)/g
-
-function toBracePath(template: string): string {
-  return template.replace(COLON_PARAM_RE, '{$1}')
-}
-
-function pathParamNames(template: string): string[] {
-  const names: string[] = []
-  for (const match of template.matchAll(COLON_PARAM_RE)) names.push(match[1]!)
-  return names
-}
-
 function buildPathFn(bracePath: string, params: string[]): string {
   if (params.length === 0) return `const val path = "${bracePath}"`
   let body = bracePath
@@ -68,19 +59,8 @@ export function emitKotlinRoute(
   ]
   const imports: string[] = []
 
-  const schema = (route as { schema?: Record<string, unknown> }).schema ?? {}
-  const input = (schema.input ?? {}) as Record<string, unknown>
-
   // Per-slot emission. Order is fixed for deterministic output.
-  const slots: Array<{ rootName: string; source: unknown }> = [
-    { rootName: 'PathParams', source: input.pathParams },
-    { rootName: 'Query', source: input.query },
-    { rootName: 'Body', source: input.body },
-    { rootName: 'Response', source: schema.returnType },
-  ]
-
-  for (const slot of slots) {
-    if (slot.source == null) continue
+  for (const slot of extractRouteSlots(route)) {
     const result = emitter.emit(slot.source as Record<string, unknown>, emitOptsFor(slot.rootName, routeOpts))
     lines.push('')
     lines.push(result.code)

package/src/codegen/targets/kotlin/emit-scope-kotlin.ts

@@ -1,7 +1,10 @@
 import type { ScopeGroup } from '../../group-routes.js'
 import type { KotlinEmitter } from './ajsc-adapter.js'
 import { emitKotlinRoute, type EmitRouteOpts } from './emit-route-kotlin.js'
-import { kotlinPackageDecl, kotlinSourceHashHeader, kotlinImports, indent, pickDefined } from './format-kotlin.js'
+import { kotlinPackageDecl, kotlinSourceHashHeader, kotlinImports } from './format-kotlin.js'
+import { indent } from '../_shared/indent.js'
+import { pickDefined } from '../_shared/pick-defined.js'
+import { pascalCase } from '../_shared/pascal-case.js'
 
 export interface EmitScopeOptions extends EmitRouteOpts {
   kotlinPackage: string
@@ -15,14 +18,6 @@ export interface EmittedKotlinFile {
   skippedStreams: string[]
 }
 
-function pascalCase(scope: string): string {
-  return scope
-    .split('-')
-    .filter((p) => p.length > 0)
-    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-    .join('')
-}
-
 export function emitKotlinScope(
   group: ScopeGroup,
   opts: EmitScopeOptions,

package/src/codegen/targets/kotlin/format-kotlin.test.ts

@@ -3,8 +3,6 @@ import {
   kotlinPackageDecl,
   kotlinSourceHashHeader,
   kotlinImports,
-  indent,
-  pickDefined,
 } from './format-kotlin.js'
 
 describe('format-kotlin', () => {
@@ -25,46 +23,4 @@ describe('format-kotlin', () => {
   it('returns empty string when no imports', () => {
     expect(kotlinImports([])).toBe('')
   })
-
-  it('indents every line by 4 spaces per level', () => {
-    expect(indent('a\nb', 1)).toBe('    a\n    b')
-    expect(indent('a', 2)).toBe('        a')
-  })
-
-  it('preserves blank lines without trailing whitespace when indenting', () => {
-    expect(indent('a\n\nb', 1)).toBe('    a\n\n    b')
-  })
-})
-
-describe('pickDefined', () => {
-  it('returns only the keys whose values are not undefined', () => {
-    expect(pickDefined({ a: 1, b: undefined, c: 3 } as { a?: number; b?: number; c?: number }, ['a', 'b', 'c']))
-      .toEqual({ a: 1, c: 3 })
-  })
-
-  it('preserves the literal `false` value for boolean opts', () => {
-    expect(pickDefined({ depluralize: false, x: undefined } as { depluralize?: boolean; x?: number }, ['depluralize', 'x']))
-      .toEqual({ depluralize: false })
-  })
-
-  it('preserves the literal `false` for `string | false` opts (e.g. arrayItemNaming)', () => {
-    type Opts = { arrayItemNaming?: string | false }
-    const result = pickDefined<Opts, keyof Opts>({ arrayItemNaming: false }, ['arrayItemNaming'])
-    expect(result).toEqual({ arrayItemNaming: false })
-    expect('arrayItemNaming' in result).toBe(true)
-  })
-
-  it('omits keys not in the keys list even if they are defined on src', () => {
-    expect(pickDefined({ a: 1, b: 2 } as { a?: number; b?: number }, ['a']))
-      .toEqual({ a: 1 })
-  })
-
-  it('returns an empty object when all keys are undefined', () => {
-    expect(pickDefined({ a: undefined, b: undefined } as { a?: number; b?: number }, ['a', 'b']))
-      .toEqual({})
-  })
-
-  it('returns an empty object when keys is empty', () => {
-    expect(pickDefined({ a: 1 }, [] as never[])).toEqual({})
-  })
 })

package/src/codegen/targets/kotlin/format-kotlin.ts

@@ -11,35 +11,3 @@ export function kotlinImports(imports: string[]): string {
   const unique = Array.from(new Set(imports)).sort()
   return unique.map((i) => `import ${i}`).join('\n')
 }
-
-export function indent(text: string, level: number): string {
-  const prefix = '    '.repeat(level)
-  return text
-    .split('\n')
-    .map((line) => (line.length === 0 ? line : `${prefix}${line}`))
-    .join('\n')
-}
-
-/**
- * Returns a new object containing only the keys of `src` whose values are
- * not `undefined`. Useful for building option objects where unset keys must
- * be ABSENT (not `undefined`-valued), so they don't shadow downstream
- * defaults — e.g., when forwarding into `KotlinEmitOptions`.
- *
- * @example
- *   pickDefined({ a: 1, b: undefined, c: false }, ['a', 'b', 'c'])
- *   // → { a: 1, c: false }
- */
-export function pickDefined<T extends object, K extends keyof T>(
-  src: T,
-  keys: readonly K[],
-): Partial<Pick<T, K>> {
-  const out: Partial<Pick<T, K>> = {}
-  for (const key of keys) {
-    const value = src[key]
-    if (value !== undefined) {
-      out[key] = value
-    }
-  }
-  return out
-}

package/src/codegen/targets/kotlin/integration.test.ts

@@ -18,7 +18,7 @@ const ok = (code: string, rootTypeName: string, imports: string[] = ['kotlinx.se
 
 describe('kotlin codegen — integration', () => {
   it('produces byte-identical output against the golden fixture', async () => {
-    const envelopePath = join(__dirname, '__fixtures__/users-envelope.json')
+    const envelopePath = join(__dirname, '../../__fixtures__/users-envelope.json')
     const goldenPath = join(__dirname, '__fixtures__/users-golden.kt')
     const envelope = JSON.parse(await readFile(envelopePath, 'utf8'))