ts-procedures 7.3.0 → 8.1.0

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

@@ -62,6 +62,23 @@ describe('swift codegen — integration', () => {
         'public struct Query: Codable {\n    public let status: Status?\n    public let limit: Int64?\n\n    public enum Status: String, Codable {\n        case active\n        case inactive\n    }\n}',
         'Query',
       ),
+
+      // DownloadUser
+      ResponseHeaders: ok(
+        'public struct ResponseHeaders: Codable {\n    public let xDownloadToken: String\n    public let contentDisposition: String?\n\n    enum CodingKeys: String, CodingKey {\n        case xDownloadToken = "x-download-token"\n        case contentDisposition = "content-disposition"\n    }\n}',
+        'ResponseHeaders',
+      ),
+
+      // WatchUsers (http-stream) — reuses Query and ResponseHeaders stubs from above;
+      // adds Yield and ReturnType which are unique to the stream route.
+      Yield: ok(
+        'public struct Yield: Codable {\n    public let id: String\n    public let event: Event\n\n    public enum Event: String, Codable {\n        case created\n        case updated\n        case deleted\n    }\n}',
+        'Yield',
+      ),
+      ReturnType: ok(
+        'public struct ReturnType: Codable {\n    public let count: Int64\n}',
+        'ReturnType',
+      ),
     })
 
     const files = await runPipeline({

package/src/create-http-stream.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest'
+import { Procedures } from './index.js'
+import { Type } from 'typebox'
+import { ProcedureValidationError } from './errors.js'
+
+describe('CreateHttpStream basic generator', () => {
+  it('registers with kind: http-stream', () => {
+    const procs = Procedures()
+    procs.CreateHttpStream('Tail', {
+      path: '/streams/logs', method: 'get',
+      schema: {
+        req: { query: Type.Object({ source: Type.String() }) },
+        yield: Type.Object({ line: Type.String() }),
+      },
+    }, async function* () { yield { line: 'a' } })
+
+    expect(procs.getProcedure('Tail')?.kind).toBe('http-stream')
+  })
+
+  it('yields and returns', async () => {
+    const procs = Procedures()
+    const { Tail } = procs.CreateHttpStream('Tail', {
+      path: '/streams/logs', method: 'get',
+      schema: {
+        req: { query: Type.Object({ source: Type.String() }) },
+        yield: Type.Object({ line: Type.String() }),
+        returnType: Type.Object({ totalLines: Type.Number() }),
+      },
+    }, async function* (_, { query }) {
+      yield { line: `from-${query.source}-1` }
+      yield { line: `from-${query.source}-2` }
+      return { totalLines: 2 }
+    })
+
+    const lines: string[] = []
+    let returnVal: unknown
+    const { stream } = await Tail({} as any, { query: { source: 'app' } })
+    let result = await stream.next()
+    while (!result.done) {
+      lines.push(result.value.line)
+      result = await stream.next()
+    }
+    returnVal = result.value
+    expect(lines).toEqual(['from-app-1', 'from-app-2'])
+    expect(returnVal).toEqual({ totalLines: 2 })
+  })
+
+  it('rejects req.query validation error before opening stream', async () => {
+    const procs = Procedures()
+    const { Tail } = procs.CreateHttpStream('Tail', {
+      path: '/streams/logs', method: 'get',
+      schema: {
+        req: { query: Type.Object({ source: Type.String() }) },
+        yield: Type.Object({ line: Type.String() }),
+      },
+    }, async function* () { yield { line: 'should not run' } })
+
+    // Two independent async calls — each rejects before a stream is produced.
+    await expect(Tail({} as any, { query: {} as any })).rejects.toThrow(ProcedureValidationError)
+    await expect(Tail({} as any, { query: {} as any })).rejects.toThrow(/req\.query/)
+  })
+})
+
+describe('CreateHttpStream async-preamble shape (res.headers)', () => {
+  it('handler returning Promise<{ headers, stream }> surfaces headers in initialHeaders', async () => {
+    const procs = Procedures()
+    const { Tail } = procs.CreateHttpStream('Tail', {
+      path: '/streams/logs', method: 'get',
+      schema: {
+        req: { query: Type.Object({ source: Type.String() }) },
+        yield: Type.Object({ line: Type.String() }),
+        res: { headers: Type.Object({ 'x-stream-id': Type.String() }) },
+      },
+    }, async (_, { query }) => ({
+      headers: { 'x-stream-id': `id-${query.source}` },
+      stream: (async function* () { yield { line: 'a' } })(),
+    }))
+
+    const { stream, initialHeaders } = await Tail({} as any, { query: { source: 'app' } })
+    expect(initialHeaders).toEqual({ 'x-stream-id': 'id-app' })
+    const first = await stream.next()
+    expect(first.value).toEqual({ line: 'a' })
+  })
+
+  it('throws when handler returns malformed shape', async () => {
+    const procs = Procedures()
+    const { Bad } = procs.CreateHttpStream('Bad', {
+      path: '/streams', method: 'get',
+      schema: {
+        yield: Type.Number(),
+        res: { headers: Type.Object({}) },
+      },
+    }, (async () => 'not-a-shape') as any)
+
+    await expect(Bad({} as any, undefined)).rejects.toThrow(/did not resolve to/)
+  })
+})

package/src/create-http-stream.ts

@@ -0,0 +1,191 @@
+import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError, ProcedureYieldValidationError } from './errors.js'
+import { computeSchema } from './schema/compute-schema.js'
+import { Prettify, TSchemaLib } from './schema/types.js'
+import { captureDefinitionInfo } from './stack-utils.js'
+import {
+  HttpMethod, TBuilderConfig, TStreamContext,
+  THttpStreamProcedureRegistration, TProcedureRegistration, TStreamProcedureRegistration, THttpProcedureRegistration,
+} from './types.js'
+import { checkPathParamConsistency } from './create-http.js'
+
+/**
+ * Wraps a user's AsyncIterator in a generator that:
+ * - optionally validates each yielded value
+ * - augments error stack traces with the procedure definition site
+ * - aborts the stream controller on completion
+ */
+async function* yieldingWrapper(
+  userIterator: AsyncIterator<any, any, unknown>,
+  validateYields: boolean,
+  validations: { yield?: (value: any) => { errors?: any[] } },
+  abortController: AbortController,
+  definitionInfo: ReturnType<typeof captureDefinitionInfo>,
+  name: string,
+): AsyncGenerator<any, any, unknown> {
+  try {
+    let result = await userIterator.next()
+    while (!result.done) {
+      const value = result.value
+      if (validateYields && validations.yield) {
+        const { errors } = validations.yield(value)
+        if (errors) throw new ProcedureYieldValidationError(name, `Yield validation error for ${name}`, errors, definitionInfo)
+      }
+      yield value
+      result = await userIterator.next()
+    }
+    return result.value
+  } catch (error: any) {
+    if (definitionInfo.definedAt && error && typeof error.stack === 'string') {
+      const { file, line, column } = definitionInfo.definedAt
+      error.stack = `${error.stack}\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
+    }
+    throw error
+  } finally {
+    try { await userIterator.return?.(undefined) } catch { /* swallow */ }
+    abortController.abort('stream-completed')
+  }
+}
+
+export function makeCreateHttpStream<TContext>(
+  procedures: Map<string, TProcedureRegistration<TContext, any> | TStreamProcedureRegistration<TContext, any> | THttpProcedureRegistration<TContext> | THttpStreamProcedureRegistration<TContext>>,
+  builder?: { config?: TBuilderConfig; onCreate?: (procedure: any) => void },
+) {
+  return function CreateHttpStream<
+    TName extends string,
+    TReq extends Record<string, unknown> | undefined,
+    TYieldType,
+    TReturnType = void,
+    TResHeaders = undefined,
+    TErrorKey extends string = string,
+  >(
+    name: TName,
+    config: {
+      path: string
+      method: HttpMethod
+      scope?: string
+      errors?: TErrorKey[]
+      description?: string
+      schema: {
+        req?: TReq
+        yield?: TYieldType
+        returnType?: TReturnType
+        res?: TResHeaders extends undefined ? undefined : { headers: TResHeaders }
+      }
+      validateYields?: boolean
+    },
+    handler: TResHeaders extends undefined
+      ? (
+          ctx: Prettify<TContext & TStreamContext>,
+          req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+        ) => AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
+      : (
+          ctx: Prettify<TContext & TStreamContext>,
+          req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+        ) => Promise<{ headers: TSchemaLib<TResHeaders>; stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown> }>,
+  ) {
+    const definitionInfo = captureDefinitionInfo()
+
+    if (procedures.has(name)) throw new Error(`Procedure with name ${name} is already registered`)
+    if ((config.schema as any)?.params) {
+      throw new ProcedureRegistrationError(name, `Use schema.req.body (or schema.req.query) instead of schema.params on CreateHttpStream. Procedure: "${name}".`, definitionInfo)
+    }
+
+    const { jsonSchema, validations } = computeSchema(name, {
+      req: config.schema.req as Record<string, unknown> | undefined,
+      yieldType: config.schema.yield,
+      returnType: config.schema.returnType,
+    }, definitionInfo)
+
+    const pathParamsSchema = (jsonSchema.req as Record<string, unknown> | undefined)?.pathParams
+    checkPathParamConsistency(name, config.path, pathParamsSchema as Record<string, unknown> | undefined, definitionInfo)
+
+    const errorFactory = (message: string, meta?: object) => new ProcedureError(name, message, meta, definitionInfo)
+    const validateYields = config.validateYields ?? false
+
+    const wrappedHandler = async (ctx: TContext, req: any): Promise<{ stream: AsyncGenerator<any, any, unknown>; initialHeaders?: Record<string, string> }> => {
+      const abortController = new AbortController()
+      const skipValidation = (ctx as { isPrevalidated?: boolean }).isPrevalidated || builder?.config?.noRuntimeValidation
+
+      if (validations?.req && !skipValidation) {
+        for (const [channel, validator] of Object.entries(validations.req)) {
+          const channelValue = (req as Record<string, unknown>)?.[channel]
+          const { errors } = validator(channelValue)
+          if (errors) {
+            throw new ProcedureValidationError(name, `Validation error for ${name} in req.${channel}`, errors, definitionInfo)
+          }
+        }
+      }
+
+      const incomingSignal = (ctx as { signal?: AbortSignal }).signal
+      const signal = incomingSignal ? AbortSignal.any([incomingSignal, abortController.signal]) : abortController.signal
+      const streamCtx: TStreamContext = { error: errorFactory, signal }
+
+      const handlerResult: any = (handler as any)({ ...ctx, ...streamCtx }, req)
+
+      if (typeof handlerResult?.[Symbol.asyncIterator] === 'function') {
+        // Plain async generator from user
+        const userIterator = (handlerResult as AsyncGenerator<any, any, unknown>)[Symbol.asyncIterator]()
+        return { stream: yieldingWrapper(userIterator, validateYields, validations, abortController, definitionInfo, name) }
+      } else if (typeof handlerResult?.then === 'function') {
+        // Async preamble: Promise<{ headers, stream }>
+        const resolved = await handlerResult
+        if (!resolved || typeof resolved !== 'object' || !('stream' in resolved)) {
+          throw new ProcedureError(name, `CreateHttpStream handler returned a Promise that did not resolve to { headers, stream }. Got: ${JSON.stringify(resolved)}`, undefined, definitionInfo)
+        }
+        const userIterator = (resolved.stream as AsyncGenerator<any, any, unknown>)[Symbol.asyncIterator]()
+        return {
+          stream: yieldingWrapper(userIterator, validateYields, validations, abortController, definitionInfo, name),
+          initialHeaders: resolved.headers,
+        }
+      } else {
+        throw new ProcedureError(name, `CreateHttpStream handler must return an AsyncGenerator or Promise<{ headers, stream }>.`, undefined, definitionInfo)
+      }
+    }
+
+    const registeredProcedure: THttpStreamProcedureRegistration<TContext> = {
+      name,
+      kind: 'http-stream',
+      config: {
+        path: config.path,
+        method: config.method,
+        scope: config.scope,
+        errors: config.errors as string[] | undefined,
+        description: config.description,
+        schema: jsonSchema as any,
+        validation: { req: validations.req, yield: validations.yield },
+        validateYields,
+      },
+      handler: wrappedHandler as any,
+    }
+
+    procedures.set(name, registeredProcedure as any)
+    builder?.onCreate?.(registeredProcedure)
+
+    const info = { name, kind: 'http-stream' as const, ...registeredProcedure.config }
+
+    // Explicit return type — preserves TReq/TYieldType/TReturnType through the public callable.
+    // Do NOT use `typeof registeredProcedure.handler` — that erases generics to `any`.
+    return {
+      [name]: registeredProcedure.handler,
+      procedure: registeredProcedure.handler,
+      info,
+    } as {
+      [K in TName]: (
+        ctx: Prettify<TContext>,
+        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+      ) => Promise<{
+        stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
+        initialHeaders?: Record<string, string>
+      }>
+    } & {
+      procedure: (
+        ctx: Prettify<TContext>,
+        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+      ) => Promise<{
+        stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>
+        initialHeaders?: Record<string, string>
+      }>
+      info: typeof info
+    }
+  }
+}

package/src/create-http.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, expectTypeOf } from 'vitest'
+import { Procedures } from './index.js'
+import { ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
+import { Type } from 'typebox'
+
+describe('CreateHttp registration', () => {
+  it('registers with kind: http', () => {
+    const procs = Procedures()
+    procs.CreateHttp('GetUser', {
+      path: '/users/:id',
+      method: 'get',
+      schema: { req: { pathParams: Type.Object({ id: Type.String() }) } },
+    }, async (_, { pathParams }) => ({ id: pathParams.id }) as any)
+
+    const reg = procs.getProcedure('GetUser')
+    expect(reg?.kind).toBe('http')
+  })
+
+  it('rejects schema.params with v8 message', () => {
+    const procs = Procedures()
+    expect(() =>
+      procs.CreateHttp('Bad', {
+        path: '/x', method: 'get',
+        schema: { params: Type.Object({}) } as any,
+      }, async () => undefined)
+    ).toThrow(/Use schema.req.body \(or schema.req.query\) instead of schema.params/)
+  })
+
+  it('rejects path with params but no pathParams schema', () => {
+    const procs = Procedures()
+    expect(() =>
+      procs.CreateHttp('Bad', {
+        path: '/users/:id', method: 'get',
+        schema: { req: {} },
+      }, async () => undefined)
+    ).toThrow(/path parameters \[id\] but schema.req.pathParams is not defined/)
+  })
+
+  it('rejects pathParams schema with no path params', () => {
+    const procs = Procedures()
+    expect(() =>
+      procs.CreateHttp('Bad', {
+        path: '/users', method: 'get',
+        schema: { req: { pathParams: Type.Object({ id: Type.String() }) } },
+      }, async () => undefined)
+    ).toThrow(/has no path parameters/)
+  })
+
+  it('rejects pathParams key mismatch', () => {
+    const procs = Procedures()
+    expect(() =>
+      procs.CreateHttp('Bad', {
+        path: '/users/:id', method: 'get',
+        schema: { req: { pathParams: Type.Object({ wrongKey: Type.String() }) } },
+      }, async () => undefined)
+    ).toThrow(/Path param mismatch/)
+  })
+})
+
+describe('CreateHttp res.body', () => {
+  it('handler returns body bare when only res.body declared', async () => {
+    const procs = Procedures()
+    const { GetUser } = procs.CreateHttp('GetUser', {
+      path: '/users/:id', method: 'get',
+      schema: {
+        req: { pathParams: Type.Object({ id: Type.String() }) },
+        res: { body: Type.Object({ id: Type.String(), name: Type.String() }) },
+      },
+    }, async (_, { pathParams }) => ({ id: pathParams.id, name: 'Alice' }))
+
+    const result = await GetUser({} as any, { pathParams: { id: '1' } })
+    expect(result).toEqual({ id: '1', name: 'Alice' })
+  })
+})
+
+describe('CreateHttp conditional return shape', () => {
+  it('res: { body, headers } → returns { body, headers }', async () => {
+    const procs = Procedures()
+    const { GetUser } = procs.CreateHttp('GetUser', {
+      path: '/users/:id', method: 'get',
+      schema: {
+        req: { pathParams: Type.Object({ id: Type.String() }) },
+        res: {
+          body: Type.Object({ id: Type.String() }),
+          headers: Type.Object({ 'x-rate-limit': Type.String() }),
+        },
+      },
+    }, async (_, { pathParams }) => ({
+      body: { id: pathParams.id },
+      headers: { 'x-rate-limit': '99' },
+    }))
+
+    const result = await GetUser({} as any, { pathParams: { id: '1' } })
+    expect(result).toEqual({ body: { id: '1' }, headers: { 'x-rate-limit': '99' } })
+  })
+
+  it('res: { headers } only → returns { headers }', async () => {
+    const procs = Procedures()
+    const { Healthcheck } = procs.CreateHttp('Healthcheck', {
+      path: '/health', method: 'get',
+      schema: {
+        res: { headers: Type.Object({ 'x-version': Type.String() }) },
+      },
+    }, async () => ({ headers: { 'x-version': '8.0.0' } }))
+
+    const result = await Healthcheck({} as any, undefined)
+    expect(result).toEqual({ headers: { 'x-version': '8.0.0' } })
+  })
+
+  it('no res → returns void', async () => {
+    const procs = Procedures()
+    const { Ping } = procs.CreateHttp('Ping', {
+      path: '/ping', method: 'post',
+      schema: { req: { body: Type.Object({}) } },
+    }, async () => undefined)
+
+    const result = await Ping({} as any, { body: {} })
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('CreateHttp HttpReturn type inference', () => {
+  it('infers correct return shapes', () => {
+    const procs = Procedures()
+    const { GetUser } = procs.CreateHttp('GetUser', {
+      path: '/users/:id', method: 'get',
+      schema: {
+        req: { pathParams: Type.Object({ id: Type.String() }) },
+        res: {
+          body: Type.Object({ id: Type.String() }),
+          headers: Type.Object({ 'x-rate-limit': Type.String() }),
+        },
+      },
+    }, async () => ({ body: { id: '1' }, headers: { 'x-rate-limit': '99' } }))
+
+    type ReturnT = Awaited<ReturnType<typeof GetUser>>
+    expectTypeOf<ReturnT>().toEqualTypeOf<{ body: { id: string }; headers: { 'x-rate-limit': string } }>()
+  })
+})
+
+describe('CreateHttp req channel validation', () => {
+  it('validates each channel independently with channel-tagged error', async () => {
+    const procs = Procedures()
+    const { GetUser } = procs.CreateHttp('GetUser', {
+      path: '/users/:id', method: 'get',
+      schema: {
+        req: {
+          pathParams: Type.Object({ id: Type.String() }),
+          query: Type.Object({ limit: Type.Number() }),
+        },
+      },
+    }, async (_, { pathParams, query }) => ({ id: pathParams.id, limit: query.limit }) as any)
+
+    await expect(GetUser({} as any, {
+      pathParams: { id: 'abc' },
+      query: { limit: 'not-a-number' as any },
+    })).rejects.toThrow(ProcedureValidationError)
+    await expect(GetUser({} as any, {
+      pathParams: { id: 'abc' },
+      query: { limit: 'not-a-number' as any },
+    })).rejects.toThrow(/req\.query/)
+  })
+})

package/src/create-http.ts

@@ -0,0 +1,211 @@
+import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
+import { computeSchema } from './schema/compute-schema.js'
+import { Prettify, TSchemaLib } from './schema/types.js'
+import { captureDefinitionInfo } from './stack-utils.js'
+import {
+  HttpMethod,
+  TBuilderConfig,
+  TCreateHttpConfig,
+  TLocalContext,
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+} from './types.js'
+
+type Infer<T> = TSchemaLib<T>
+
+export type HttpReturn<TRes> =
+  TRes extends { body: infer B; headers: infer H } ? { body: Infer<B>; headers: Infer<H> }
+  : TRes extends { headers: infer H }              ? { headers: Infer<H> }
+  : TRes extends { body: infer B }                 ? Infer<B>
+  : void
+
+const PATH_PARAM_RE = /:([a-zA-Z_][a-zA-Z0-9_]*)/g
+
+function extractPathParamNames(path: string): string[] {
+  const matches = path.match(PATH_PARAM_RE)
+  return matches ? matches.map((m) => m.slice(1)) : []
+}
+
+export function checkPathParamConsistency(
+  procedureName: string,
+  path: string,
+  pathParamsSchema: Record<string, unknown> | undefined,
+  definitionInfo: ReturnType<typeof captureDefinitionInfo>,
+) {
+  const pathParamNames = extractPathParamNames(path)
+  const hasPathParams = pathParamNames.length > 0
+  const hasSchema = pathParamsSchema !== undefined
+
+  if (hasPathParams && !hasSchema) {
+    throw new ProcedureRegistrationError(
+      procedureName,
+      `Path "${path}" has path parameters [${pathParamNames.join(', ')}] but schema.req.pathParams is not defined.`,
+      definitionInfo,
+    )
+  }
+  if (!hasPathParams && hasSchema) {
+    throw new ProcedureRegistrationError(
+      procedureName,
+      `schema.req.pathParams is defined but path "${path}" has no path parameters.`,
+      definitionInfo,
+    )
+  }
+  if (hasPathParams && hasSchema) {
+    const schemaProperties = (pathParamsSchema as { properties?: Record<string, unknown> }).properties
+    if (schemaProperties) {
+      const schemaKeys = Object.keys(schemaProperties)
+      const missing = pathParamNames.filter((p) => !schemaKeys.includes(p))
+      const extra = schemaKeys.filter((k) => !pathParamNames.includes(k))
+      if (missing.length > 0 || extra.length > 0) {
+        const parts: string[] = []
+        if (missing.length > 0) parts.push(`path has [${missing.join(', ')}] missing from schema`)
+        if (extra.length > 0) parts.push(`schema has [${extra.join(', ')}] not in path`)
+        throw new ProcedureRegistrationError(
+          procedureName,
+          `Path param mismatch for "${procedureName}": ${parts.join('; ')}.`,
+          definitionInfo,
+        )
+      }
+    }
+  }
+}
+
+export function makeCreateHttp<TContext>(
+  procedures: Map<
+    string,
+    | TProcedureRegistration<TContext, any>
+    | TStreamProcedureRegistration<TContext, any>
+    | THttpProcedureRegistration<TContext>
+    | THttpStreamProcedureRegistration<TContext>
+  >,
+  builder?: { config?: TBuilderConfig; onCreate?: (procedure: any) => void },
+) {
+  return function CreateHttp<
+    TName extends string,
+    TReq extends Record<string, unknown> | undefined,
+    TRes extends { body?: unknown; headers?: unknown } | undefined = undefined,
+    TErrorKey extends string = string,
+  >(
+    name: TName,
+    config: TCreateHttpConfig<TReq, TRes, TErrorKey>,
+    handler: (
+      ctx: Prettify<TContext & TLocalContext>,
+      req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+    ) => Promise<HttpReturn<TRes>>,
+  ) {
+    const definitionInfo = captureDefinitionInfo()
+
+    if (procedures.has(name)) {
+      throw new Error(`Procedure with name ${name} is already registered`)
+    }
+
+    if ((config.schema as any)?.params) {
+      throw new ProcedureRegistrationError(
+        name,
+        `Use schema.req.body (or schema.req.query) instead of schema.params on CreateHttp. Procedure: "${name}".`,
+        definitionInfo,
+      )
+    }
+
+    const { jsonSchema, validations } = computeSchema(
+      name,
+      {
+        req: config.schema.req as Record<string, unknown> | undefined,
+        res: config.schema.res as { body?: unknown; headers?: unknown } | undefined,
+      },
+      definitionInfo,
+    )
+
+    const pathParamsSchema = (jsonSchema.req as Record<string, unknown> | undefined)?.pathParams
+    checkPathParamConsistency(
+      name,
+      config.path,
+      pathParamsSchema as Record<string, unknown> | undefined,
+      definitionInfo,
+    )
+
+    const errorFactory = (message: string, meta?: object) =>
+      new ProcedureError(name, message, meta, definitionInfo)
+
+    const registeredProcedure: THttpProcedureRegistration<TContext> = {
+      name,
+      kind: 'http',
+      config: {
+        path: config.path,
+        method: config.method,
+        successStatus: config.successStatus,
+        scope: config.scope,
+        errors: config.errors as string[] | undefined,
+        description: config.description,
+        schema: jsonSchema as any,
+        validation: { req: validations.req },
+      },
+      handler: async (ctx: TContext, req: any) => {
+        try {
+          const skipValidation =
+            (ctx as { isPrevalidated?: boolean }).isPrevalidated ||
+            builder?.config?.noRuntimeValidation
+
+          if (validations?.req && !skipValidation) {
+            for (const [channel, validator] of Object.entries(validations.req)) {
+              const channelValue = (req as Record<string, unknown>)?.[channel]
+              const { errors } = validator(channelValue)
+              if (errors) {
+                throw new ProcedureValidationError(
+                  name,
+                  `Validation error for ${name} in req.${channel}`,
+                  errors,
+                  definitionInfo,
+                )
+              }
+            }
+          }
+
+          const localCtx: TLocalContext = { error: errorFactory }
+          return await handler({ ...ctx, ...localCtx } as any, req)
+        } catch (error: any) {
+          if (error instanceof ProcedureError) throw error
+          const err = new ProcedureError(
+            name,
+            `Error in handler for ${name} - ${error?.message}`,
+            undefined,
+            definitionInfo,
+          )
+          err.cause = error
+          if (error.stack && definitionInfo.definedAt) {
+            const { file, line, column } = definitionInfo.definedAt
+            err.stack =
+              error.stack + `\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
+          } else if (error.stack) {
+            err.stack = error.stack
+          }
+          throw err
+        }
+      },
+    }
+
+    procedures.set(name, registeredProcedure as any)
+    builder?.onCreate?.(registeredProcedure)
+
+    const info = { name, ...registeredProcedure.config }
+
+    return {
+      [name]: registeredProcedure.handler,
+      procedure: registeredProcedure.handler,
+      info,
+    } as {
+      [K in TName]: (
+        ctx: Prettify<TContext>,
+        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+      ) => Promise<HttpReturn<TRes>>
+    } & {
+      procedure: (
+        ctx: Prettify<TContext>,
+        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
+      ) => Promise<HttpReturn<TRes>>
+      info: typeof info
+    }
+  }
+}