ts-procedures 7.3.0 → 8.0.0

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
+    }
+  }
+}