ts-procedures 8.6.0 → 9.1.0

package/src/implementations/http/hono/handlers/http.ts

@@ -1,145 +0,0 @@
-import type { Context, Hono } from 'hono'
-import type { THttpProcedureRegistration } from '../../../../types.js'
-import type { HttpMethod } from '../../../types.js'
-import { dispatchPreStreamError } from '../../error-dispatch.js'
-import { buildHttpRouteDoc } from '../docs/http-doc.js'
-import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem, QueryParser } from '../types.js'
-
-const BODY_METHODS: HttpMethod[] = ['post', 'put', 'patch']
-
-function defaultSuccessStatus(method: HttpMethod): number {
-  switch (method) {
-    case 'post':   return 201
-    case 'delete': return 204
-    default:       return 200
-  }
-}
-
-function parseQueryNative(queryString: string): Record<string, unknown> {
-  const sp = new URLSearchParams(queryString)
-  const result: Record<string, unknown> = {}
-  for (const key of new Set(sp.keys())) {
-    const values = sp.getAll(key)
-    result[key] = values.length > 1 ? values : values[0]
-  }
-  return result
-}
-
-function extractQuery(url: string, parser: QueryParser): Record<string, unknown> {
-  const q = url.indexOf('?')
-  if (q === -1) return {}
-  const raw = url.slice(q + 1)
-  return raw ? parser(raw) : {}
-}
-
-async function extractParams(
-  c: Context,
-  method: HttpMethod,
-  reqSchema: Record<string, unknown>,
-  parser: QueryParser,
-): Promise<Record<string, unknown>> {
-  const params: Record<string, unknown> = {}
-  for (const channel of Object.keys(reqSchema)) {
-    switch (channel) {
-      case 'pathParams':
-        params.pathParams = c.req.param()
-        break
-      case 'query':
-        params.query = extractQuery(c.req.url, parser)
-        break
-      case 'body':
-        if (BODY_METHODS.includes(method)) {
-          params.body = await c.req.json().catch(() => ({}))
-        }
-        break
-      case 'headers': {
-        const obj: Record<string, string> = {}
-        c.req.raw.headers.forEach((v, k) => { obj[k] = v })
-        params.headers = obj
-        break
-      }
-      default:
-        params[channel] = undefined
-    }
-  }
-  return params
-}
-
-export function installHttpRoute(params: {
-  app: Hono
-  procedure: THttpProcedureRegistration<any>
-  factoryItem: HonoFactoryItem
-  cfg: HonoAppBuilderConfig
-  docs: DocAccumulator
-}): void {
-  const { app, procedure, factoryItem, cfg, docs } = params
-  const queryParser = cfg.api?.queryParser ?? parseQueryNative
-
-  const route = buildHttpRouteDoc(
-    procedure,
-    cfg.pathPrefix,
-    factoryItem.extendProcedureDoc as any,
-  )
-  docs.push(route)
-
-  const successStatus = procedure.config.successStatus ?? defaultSuccessStatus(procedure.config.method)
-  const reqSchema = procedure.config.schema?.req
-
-  app.on(procedure.config.method.toUpperCase(), route.fullPath, async (c: Context) => {
-    try {
-      const context =
-        typeof factoryItem.factoryContext === 'function'
-          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
-          : factoryItem.factoryContext
-
-      const reqParams = reqSchema
-        ? await extractParams(c, procedure.config.method, reqSchema, queryParser)
-        : undefined
-
-      const result = await procedure.handler(
-        { ...context, signal: c.req.raw.signal },
-        reqParams,
-      )
-
-      cfg.api?.onSuccess?.(procedure, c)
-
-      // The `{ body, headers }` envelope is OPT-IN via `schema.res.headers`: when
-      // the route declares response headers, the handler returns `{ body, headers }`;
-      // otherwise its return value IS the body. Gating on the schema (rather than
-      // duck-typing the result for a `body`/`headers` key) lets a domain object
-      // safely carry its own `body`/`headers` field without being unwrapped.
-      // Normalize both shapes to a single `{ body, headers }` so the response
-      // decision below is uniform for every legal return shape.
-      const hasResHeaders = procedure.config.schema?.res?.headers != null
-      const { body, headers } = hasResHeaders
-        ? ((result ?? {}) as { body?: unknown; headers?: unknown })
-        : { body: result, headers: undefined }
-
-      if (headers && typeof headers === 'object') {
-        for (const [k, v] of Object.entries(headers as Record<string, string>)) c.header(k, v)
-      }
-
-      // No body to send — a 204 status, or an `undefined` return (a `void`
-      // handler, or a headers-only `res: { headers }` envelope). Emit a clean
-      // bodyless response instead of `c.json(undefined)`, which would send an
-      // empty, unparseable body under an `application/json` content-type.
-      if (successStatus === 204 || body === undefined) {
-        return c.body(null, successStatus as any)
-      }
-
-      return c.json(body, successStatus as any)
-    } catch (error) {
-      return dispatchPreStreamError({
-        err: error,
-        procedure,
-        raw: c,
-        cfg: {
-          errors: cfg.errors,
-          unknownError: cfg.unknownError,
-          onError: cfg.onError,
-          onRequestError: cfg.onRequestError,
-        },
-      })
-    }
-  })
-}

package/src/implementations/http/hono/handlers/rpc.ts

@@ -1,54 +0,0 @@
-import type { Context, Hono } from 'hono'
-import type { TProcedureRegistration } from '../../../../types.js'
-import type { RPCConfig } from '../../../types.js'
-import { dispatchPreStreamError } from '../../error-dispatch.js'
-import { buildRpcRouteDoc } from '../docs/rpc-doc.js'
-import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem } from '../types.js'
-
-export function installRpcRoute(params: {
-  app: Hono
-  procedure: TProcedureRegistration<any, RPCConfig>
-  factoryItem: HonoFactoryItem
-  cfg: HonoAppBuilderConfig
-  docs: DocAccumulator
-}): void {
-  const { app, procedure, factoryItem, cfg, docs } = params
-
-  const route = buildRpcRouteDoc(
-    procedure,
-    cfg.pathPrefix,
-    factoryItem.extendProcedureDoc as any,
-  )
-  docs.push(route)
-
-  app.post(route.path, async (c: Context) => {
-    try {
-      const context =
-        typeof factoryItem.factoryContext === 'function'
-          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
-          : factoryItem.factoryContext
-
-      const body = await c.req.json().catch(() => ({}))
-      const result = await procedure.handler(
-        { ...context, signal: c.req.raw.signal },
-        body,
-      )
-
-      cfg.rpc?.onSuccess?.(procedure, c)
-
-      return c.json(result)
-    } catch (error) {
-      return dispatchPreStreamError({
-        err: error,
-        procedure,
-        raw: c,
-        cfg: {
-          errors: cfg.errors,
-          unknownError: cfg.unknownError,
-          onError: cfg.onError,
-          onRequestError: cfg.onRequestError,
-        },
-      })
-    }
-  })
-}

package/src/implementations/http/hono/path.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { makeRoutePath, resolveFullPath } from './path.js'
-import type {
-  TProcedureRegistration,
-  TStreamProcedureRegistration,
-  THttpProcedureRegistration,
-  THttpStreamProcedureRegistration,
-} from '../../../types.js'
-
-describe('makeRoutePath', () => {
-  test('rpc: scope/name/version with kebab-case', () => {
-    const proc = {
-      name: 'GetUser',
-      kind: 'rpc',
-      config: { scope: 'users', version: 1 },
-      handler: async () => undefined,
-    } as unknown as TProcedureRegistration
-    expect(makeRoutePath({ procedure: proc })).toBe('/users/get-user/1')
-  })
-
-  test('rpc: array scope joined with /', () => {
-    const proc = {
-      name: 'List',
-      kind: 'rpc',
-      config: { scope: ['UserModule', 'admin'], version: 2 },
-      handler: async () => undefined,
-    } as unknown as TProcedureRegistration
-    expect(makeRoutePath({ procedure: proc })).toBe('/user-module/admin/list/2')
-  })
-
-  test('rpc: pathPrefix is normalized (leading slash inserted)', () => {
-    const proc = {
-      name: 'Echo',
-      kind: 'rpc',
-      config: { scope: 'echo', version: 1 },
-      handler: async () => undefined,
-    } as unknown as TProcedureRegistration
-    expect(makeRoutePath({ procedure: proc, prefix: 'api/v1' })).toBe('/api/v1/echo/echo/1')
-  })
-
-  test('rpc-stream: same shape as rpc', () => {
-    const proc = {
-      name: 'Tail',
-      kind: 'rpc-stream',
-      isStream: true,
-      config: { scope: 'logs', version: 1 },
-      handler: async function* () {},
-    } as unknown as TStreamProcedureRegistration
-    expect(makeRoutePath({ procedure: proc, prefix: '/api' })).toBe('/api/logs/tail/1')
-  })
-
-  test('http: prepends prefix to config.path', () => {
-    const proc = {
-      name: 'GetUser',
-      kind: 'http',
-      config: { path: '/users/:id', method: 'get' },
-      handler: async () => undefined,
-    } as unknown as THttpProcedureRegistration
-    expect(makeRoutePath({ procedure: proc, prefix: '/api/v1' })).toBe('/api/v1/users/:id')
-  })
-
-  test('http: leading slash on path is preserved (not duplicated)', () => {
-    const proc = {
-      name: 'Get',
-      kind: 'http',
-      config: { path: 'users', method: 'get' },
-      handler: async () => undefined,
-    } as unknown as THttpProcedureRegistration
-    expect(makeRoutePath({ procedure: proc, prefix: '/api' })).toBe('/api/users')
-  })
-
-  test('http-stream: same shape as http', () => {
-    const proc = {
-      name: 'TailLogs',
-      kind: 'http-stream',
-      config: { path: '/logs/tail', method: 'get' },
-      handler: async () => ({ stream: (async function* () {})(), initialHeaders: undefined }),
-    } as unknown as THttpStreamProcedureRegistration
-    expect(makeRoutePath({ procedure: proc })).toBe('/logs/tail')
-  })
-})
-
-describe('resolveFullPath', () => {
-  test('combines prefix and path', () => {
-    expect(resolveFullPath('/users', '/api/v1')).toBe('/api/v1/users')
-  })
-  test('normalizes prefix without leading slash', () => {
-    expect(resolveFullPath('/users', 'api')).toBe('/api/users')
-  })
-  test('normalizes path without leading slash', () => {
-    expect(resolveFullPath('users', '/api')).toBe('/api/users')
-  })
-  test('no prefix', () => {
-    expect(resolveFullPath('/users')).toBe('/users')
-  })
-})

package/src/index.ts

@@ -1,101 +0,0 @@
-import type { Prettify } from './schema/types.js'
-import { makeCreate } from './create.js'
-import { makeCreateStream } from './create-stream.js'
-import { makeCreateHttp } from './create-http.js'
-import { makeCreateHttpStream } from './create-http-stream.js'
-
-export {
-  type TNoContextProvided,
-  type TLocalContext,
-  type TStreamContext,
-  type ProcedureKind,
-  type TProcedureRegistration,
-  type TStreamProcedureRegistration,
-  type THttpProcedureRegistration,
-  type THttpStreamProcedureRegistration,
-  type TBuilderConfig,
-} from './types.js'
-
-import type {
-  TNoContextProvided,
-  TBuilderConfig,
-  TProcedureRegistration,
-  TStreamProcedureRegistration,
-  THttpProcedureRegistration,
-  THttpStreamProcedureRegistration,
-} from './types.js'
-
-export function Procedures<TContext = TNoContextProvided, TExtendedConfig = unknown>(
-  /**
-   * Optionally provided builder to register Procedures
-   */
-  builder?: {
-    config?: TBuilderConfig
-    /**
-     * Called once per registered procedure. Receives the full registration
-     * object for any of the four procedure kinds:
-     *   - `TProcedureRegistration`       (Create)
-     *   - `TStreamProcedureRegistration` (CreateStream)
-     *   - `THttpProcedureRegistration`   (CreateHttp)
-     *   - `THttpStreamProcedureRegistration` (CreateHttpStream)
-     *
-     * Use the `kind` discriminant to narrow to the specific shape.
-     */
-    onCreate?: (
-      procedure: Prettify<
-        | TProcedureRegistration<TContext, TExtendedConfig>
-        | TStreamProcedureRegistration<TContext, TExtendedConfig>
-        | THttpProcedureRegistration<TContext>
-        | THttpStreamProcedureRegistration<TContext>
-      >
-    ) => void
-  }
-) {
-  const procedures: Map<
-    string,
-    | TProcedureRegistration<TContext, TExtendedConfig>
-    | TStreamProcedureRegistration<TContext, TExtendedConfig>
-    | THttpProcedureRegistration<TContext>
-    | THttpStreamProcedureRegistration<TContext>
-  > = new Map()
-
-  const Create = makeCreate<TContext, TExtendedConfig>(procedures, builder)
-  const CreateStream = makeCreateStream<TContext, TExtendedConfig>(procedures, builder)
-  const CreateHttp = makeCreateHttp<TContext>(procedures, builder)
-  const CreateHttpStream = makeCreateHttpStream<TContext>(procedures, builder)
-
-  return {
-    /**
-     * Get all registered procedures
-     */
-    getProcedures: () => {
-      return Array.from(procedures.values())
-    },
-
-    /**
-     * Get a specific procedure by name
-     */
-    getProcedure: (name: string) => {
-      return procedures.get(name)
-    },
-
-    /**
-     * Remove a procedure by name
-     */
-    removeProcedure: (name: string) => {
-      return procedures.delete(name)
-    },
-
-    /**
-     * Clear all registered procedures
-     */
-    clear: () => {
-      procedures.clear()
-    },
-
-    Create,
-    CreateStream,
-    CreateHttp,
-    CreateHttpStream,
-  }
-}

package/src/schema/extract-json-schema.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { Type } from 'typebox'
-import { v } from 'suretype'
-import { extractJsonSchema } from './extract-json-schema.js'
-
-describe('extractJsonSchema()', () => {
-  const typebox = Type.Object({ name: Type.String() })
-  const suretype = v.object({ name: v.string().required() })
-
-  test('it extracts TypeBox json-schema', async () => {
-    expect(extractJsonSchema(typebox)).toMatchObject({
-      type: 'object',
-      properties: { name: { type: 'string' } },
-      required: ['name'],
-    })
-  })
-
-  test('it extracts Suretype json-schema', async () => {
-    expect(extractJsonSchema(suretype)).toMatchObject({
-      type: 'object',
-      properties: { name: { type: 'string' } },
-      required: ['name'],
-    })
-  })
-})

package/src/schema/extract-json-schema.ts

@@ -1,15 +0,0 @@
-import { extractSingleJsonSchema } from 'suretype'
-import { isSuretypeSchema, isTypeboxSchema } from './resolve-schema-lib.js'
-import type { TJSONSchema } from './types.js'
-
-export function extractJsonSchema(libSchema: unknown): TJSONSchema | undefined {
-  if (isTypeboxSchema(libSchema)) {
-    return libSchema
-  }
-
-  if (isSuretypeSchema(libSchema)) {
-    return extractSingleJsonSchema(libSchema)?.schema
-  }
-
-  return undefined
-}

package/src/schema/parser.test.ts

@@ -1,182 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { extractSingleJsonSchema, v } from 'suretype'
-import { schemaParser } from './parser.js'
-import { Type } from 'typebox'
-
-describe('schemaParser', () => {
-  test('it parses params to json-schema', async () => {
-    let done: () => void = () => void 0
-    const promise = new Promise<void>((r) => {
-      done = r
-    })
-
-    const params = v.object({
-      name: v.string(),
-      age: v.number(),
-    })
-
-    const result = schemaParser(
-      {
-        params: params,
-      },
-      (errors) => {
-        throw new Error(JSON.stringify(errors))
-      },
-    )
-
-    expect(result.jsonSchema.params).toEqual(
-      extractSingleJsonSchema(params)?.schema,
-    )
-
-    done()
-
-    await promise
-    await promise
-  })
-
-  test('it parses params and generates a validator function', async () => {
-    let done: () => void = () => void 0
-    const promise = new Promise<void>((r) => {
-      done = r
-    })
-
-    const params = v.object({
-      name: v.string(),
-      age: v.number().required(),
-    })
-
-    const result = schemaParser(
-      {
-        params: params,
-      },
-      (errors) => {
-        throw new Error(JSON.stringify(errors))
-      },
-    )
-
-    expect(
-      result.validation.params?.({
-        name: 'John',
-        age: 30,
-      })?.errors,
-    ).toBeUndefined()
-
-    expect(
-      result.validation.params?.({
-        name: { name: '' },
-        age: 'poop',
-      })?.errors,
-    ).toBeDefined()
-
-    expect(
-      result.validation.params?.({
-        name: { name: '' },
-        age: 'poop',
-      })?.errors?.length,
-    ).toEqual(2)
-
-    done()
-
-    await promise
-  })
-
-  test('it parses returnType to json-schema', async () => {
-    let done: () => void = () => void 0
-    const promise = new Promise<void>((r) => {
-      done = r
-    })
-
-    const returnType = v.object({
-      name: v.string(),
-      age: v.number(),
-    })
-
-    const result = schemaParser(
-      {
-        returnType: returnType,
-      },
-      (errors) => {
-        throw new Error(JSON.stringify(errors))
-      },
-    )
-
-    expect(result.jsonSchema.returnType).toEqual(
-      extractSingleJsonSchema(returnType)?.schema,
-    )
-
-    done()
-
-    await promise
-  })
-
-  test('it throws a meaningful error to the dev', async () => {
-    schemaParser(
-      // invalid params schema
-      { params: { test: Type.String() } },
-      (errors) => {
-        expect(errors.params).toMatch(/Error extracting json schema schema.params/)
-      },
-    )
-
-    schemaParser(
-      // invalid returnType schema
-      { returnType: 'string value' },
-      (errors) => {
-        expect(errors.returnType).toMatch(/Error extracting json schema schema.returnType/)
-      },
-    )
-  })
-
-  test('it parses multiple schemas correct', async () => {
-    const schema = schemaParser(
-      {
-        params: Type.Object({ a: Type.String() }),
-        returnType: Type.Object({ b: Type.Null() }),
-      },
-      (error) => {
-        throw new Error(JSON.stringify(error))
-      },
-    )
-
-    const schema2= schemaParser(
-      {
-        params: Type.Object({ c: Type.String() }),
-        returnType: Type.Object({ d: Type.Number() }),
-      },
-      (error) => {
-        throw new Error(JSON.stringify(error))
-      },
-    )
-
-    expect(schema.validation.params?.({}).errors?.[0]?.message).toMatch(/must have required property 'a'/)
-    expect(schema2.validation.params?.({ c: 'test' })
-    ).toMatchObject({})
-    expect(schema.validation.params?.({}).errors?.[0]?.message).toMatch(/must have required property 'a'/)
-  })
-
-  test('validation returns error if validator fails to initialize', async () => {
-    // Create a schema that will pass extraction but creates a validation function
-    // that handles the uninitialized case gracefully
-    let parseErrorCalled = false
-    
-    const result = schemaParser(
-      {
-        // Using a valid schema to get through extraction, but we'll test the guard
-        params: Type.Object({ name: Type.String() }),
-      },
-      () => {
-        parseErrorCalled = true
-      },
-    )
-
-    // The validator should be initialized for valid schemas
-    expect(result.validation.params).toBeDefined()
-    
-    // Test that the validation function works correctly
-    const validResult = result.validation.params?.({ name: 'test' })
-    expect(validResult?.errors).toBeUndefined()
-    
-    const invalidResult = result.validation.params?.({})
-    expect(invalidResult?.errors).toBeDefined()
-  })
-})