ts-procedures 8.6.0 → 9.0.0

package/src/schema/parser.ts

@@ -1,265 +0,0 @@
-import { default as addFormats } from 'ajv-formats'
-import * as AJV from 'ajv'
-import { extractJsonSchema } from './extract-json-schema.js'
-import type { TJSONSchema } from './types.js'
-
-export type TSchemaParsed = {
-  jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    req?: Record<string, TJSONSchema>
-    res?: { body?: TJSONSchema; headers?: TJSONSchema }
-  }
-  validation: {
-    params?: (params: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value: any) => { errors?: TSchemaValidationError[] }
-    req?: Record<string, (value: any) => { errors?: TSchemaValidationError[] }>
-  }
-}
-
-export type TSchemaValidationError = AJV.ErrorObject
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-expect-error
-const ajv = addFormats(
-  new AJV.Ajv({
-    allErrors: true,
-    coerceTypes: true,
-    removeAdditional: true,
-  })
-)
-
-export function schemaParser(
-  schema: {
-    params?: unknown
-    returnType?: unknown
-    yieldType?: unknown
-    req?: Record<string, unknown>
-    res?: { body?: unknown; headers?: unknown }
-  },
-  onParseError: (errors: Record<string, string>) => void
-): TSchemaParsed {
-  const jsonSchema: TSchemaParsed['jsonSchema'] = {}
-  const validation: TSchemaParsed['validation'] = {}
-
-  if (schema.params) {
-    try {
-      const extracted = extractJsonSchema(schema.params as TJSONSchema)
-
-      if (extracted) {
-        jsonSchema.params = extracted
-      }
-    } catch (e: any) {
-      onParseError({
-        params: `Error extracting json schema schema.params - ${e.message}`,
-      })
-    }
-
-    if (!jsonSchema.params) {
-      onParseError({
-        params: `Error extracting json schema schema.params - schema.params might be empty or it is not a valid suretype or typebox type`,
-      })
-    } else {
-      let paramsValidator: AJV.ValidateFunction | undefined
-
-      try {
-        paramsValidator = ajv.compile(jsonSchema.params as TJSONSchema)
-      } catch (e: any) {
-        onParseError({
-          params: `Error compiling schema.params for validator - ${e.message}`,
-        })
-      }
-
-      validation.params = (params: any) => {
-        if (!paramsValidator) {
-          return { errors: [{ message: 'Validator not initialized', keyword: 'internal' } as TSchemaValidationError] }
-        }
-
-        const valid = paramsValidator(params)
-
-        if (!valid) {
-          const errors = paramsValidator.errors
-
-          return {
-            errors: errors?.length ? errors : undefined,
-          }
-        }
-
-        return {}
-      }
-    }
-  }
-
-  if (schema.returnType) {
-    try {
-      const extracted = extractJsonSchema(schema.returnType as TJSONSchema)
-
-      jsonSchema.returnType = extracted
-    } catch (e: any) {
-      onParseError({
-        returnType: `Error extracting json schema schema.returnType - ${e.message}`,
-      })
-    }
-
-    if (!jsonSchema.returnType) {
-      onParseError({
-        returnType: `Error extracting json schema schema.returnType - schema.returnType might be empty or it is not a valid suretype or typebox type`,
-      })
-    }
-  }
-
-  if (schema.yieldType) {
-    try {
-      const extracted = extractJsonSchema(schema.yieldType as TJSONSchema)
-
-      if (extracted) {
-        jsonSchema.yieldType = extracted
-      }
-    } catch (e: any) {
-      onParseError({
-        yieldType: `Error extracting json schema schema.yieldType - ${e.message}`,
-      })
-    }
-
-    if (!jsonSchema.yieldType) {
-      onParseError({
-        yieldType: `Error extracting json schema schema.yieldType - schema.yieldType might be empty or it is not a valid suretype or typebox type`,
-      })
-    } else {
-      let yieldValidator: AJV.ValidateFunction | undefined
-
-      try {
-        yieldValidator = ajv.compile(jsonSchema.yieldType as TJSONSchema)
-      } catch (e: any) {
-        onParseError({
-          yieldType: `Error compiling schema.yieldType for validator - ${e.message}`,
-        })
-      }
-
-      validation.yield = (value: any) => {
-        if (!yieldValidator) {
-          return { errors: [{ message: 'Validator not initialized', keyword: 'internal' } as TSchemaValidationError] }
-        }
-
-        const valid = yieldValidator(value)
-
-        if (!valid) {
-          const errors = yieldValidator.errors
-
-          return {
-            errors: errors?.length ? errors : undefined,
-          }
-        }
-
-        return {}
-      }
-    }
-  }
-
-  if (schema.req) {
-    jsonSchema.req = {}
-    validation.req = {}
-
-    for (const [channelName, channelSchema] of Object.entries(schema.req)) {
-      if (!channelSchema) continue
-
-      let channelJsonSchema: TJSONSchema | undefined
-
-      try {
-        const extracted = extractJsonSchema(channelSchema as TJSONSchema)
-        if (extracted) {
-          channelJsonSchema = extracted
-          jsonSchema.req![channelName] = extracted
-        }
-      } catch (e: any) {
-        onParseError({
-          [`req.${channelName}`]: `Error extracting json schema schema.req.${channelName} - ${e.message}`,
-        })
-      }
-
-      if (!channelJsonSchema) {
-        onParseError({
-          [`req.${channelName}`]: `Error extracting json schema schema.req.${channelName} - might be empty or not a valid suretype or typebox type`,
-        })
-      } else {
-        let channelValidator: AJV.ValidateFunction | undefined
-
-        try {
-          channelValidator = ajv.compile(channelJsonSchema as TJSONSchema)
-        } catch (e: any) {
-          onParseError({
-            [`req.${channelName}`]: `Error compiling schema.req.${channelName} for validator - ${e.message}`,
-          })
-        }
-
-        validation.req![channelName] = (value: any) => {
-          if (!channelValidator) {
-            return {
-              errors: [
-                { message: 'Validator not initialized', keyword: 'internal' } as TSchemaValidationError,
-              ],
-            }
-          }
-
-          const valid = channelValidator(value)
-
-          if (!valid) {
-            const errors = channelValidator.errors
-
-            return {
-              errors: errors?.length ? errors : undefined,
-            }
-          }
-
-          return {}
-        }
-      }
-    }
-  }
-
-  // res: compute JSON Schema for body and headers (documentation/codegen only — no validators)
-  if (schema.res) {
-    jsonSchema.res = {}
-
-    if (schema.res.body) {
-      try {
-        const extracted = extractJsonSchema(schema.res.body as TJSONSchema)
-        if (extracted) {
-          jsonSchema.res.body = extracted
-        }
-      } catch (e: any) {
-        onParseError({
-          'res.body': `Error extracting json schema schema.res.body - ${e.message}`,
-        })
-      }
-
-      if (!jsonSchema.res.body) {
-        onParseError({
-          'res.body': `Error extracting json schema schema.res.body - might be empty or not a valid suretype or typebox type`,
-        })
-      }
-    }
-
-    if (schema.res.headers) {
-      try {
-        const extracted = extractJsonSchema(schema.res.headers as TJSONSchema)
-        if (extracted) {
-          jsonSchema.res.headers = extracted
-        }
-      } catch (e: any) {
-        onParseError({
-          'res.headers': `Error extracting json schema schema.res.headers - ${e.message}`,
-        })
-      }
-
-      if (!jsonSchema.res.headers) {
-        onParseError({
-          'res.headers': `Error extracting json schema schema.res.headers - might be empty or not a valid suretype or typebox type`,
-        })
-      }
-    }
-  }
-
-  return { jsonSchema, validation }
-}

package/src/schema/resolve-schema-lib.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { isSuretypeSchema, isTypeboxSchema } from './resolve-schema-lib.js'
-import { Type } from 'typebox'
-import { v } from 'suretype'
-
-describe('lib schema resolvers', () => {
-  const typebox = Type.Object({ name: Type.String() })
-  const suretype = v.object({ name: v.string() })
-
-  test('it recognizes TypeBox schema', async () => {
-    expect(isTypeboxSchema(typebox)).toBe(true)
-    expect(isTypeboxSchema(suretype)).toBe(false)
-  })
-
-  test('it recognizes Suretype schema', async () => {
-    expect(isSuretypeSchema(suretype)).toBe(true)
-    expect(isSuretypeSchema(typebox)).toBe(false)
-  })
-})

package/src/schema/resolve-schema-lib.ts

@@ -1,29 +0,0 @@
-import type { CoreValidator } from 'suretype'
-import type { Type } from 'typebox'
-
-export type IsTypeboxSchema<TSchema> = TSchema extends {
-  static: unknown
-  params: unknown
-}
-  ? true
-  : false
-
-export function isTypeboxSchema(schema: any): schema is Type.TSchema {
-  return (
-    //  typebox v1
-    (typeof schema === 'object' && '~kind' in schema) ||
-    // @sinclair/typebox v0.3x
-    (typeof schema === 'object' && Symbol.for('TypeBox.Kind') in schema)
-  )
-}
-
-export type IsSuretypeSchema<TSchema> = TSchema extends {
-  required: () => object
-  nullable?: never
-}
-  ? true
-  : false
-
-export function isSuretypeSchema(schema: any): schema is CoreValidator<any> {
-  return typeof schema === 'object' && 'getJsonSchemaObject' in schema
-}

package/src/schema/types.ts

@@ -1,20 +0,0 @@
-import type { CoreValidator, TypeOf } from 'suretype'
-import type { Static, TSchema } from 'typebox'
-
-// Determine if the generic "SchemaLibType" is Suretype's CoreValidator or Typebox's TSchema
-export type TSchemaLib<SchemaLibType> =
-  SchemaLibType extends CoreValidator<any>
-    ? TypeOf<SchemaLibType>
-    : SchemaLibType extends TSchema
-      ? Static<SchemaLibType>
-      : unknown
-
-// AsyncGenerator type extraction for streaming procedures
-export type TSchemaLibGenerator<TYield, TReturn = void> =
-  AsyncGenerator<TSchemaLib<TYield>, TSchemaLib<TReturn>, unknown>
-
-export type TJSONSchema = Record<string, any>
-
-export type Prettify<TObject> = {
-  [Key in keyof TObject]: TObject[Key]
-} & {}

package/src/types.ts

@@ -1,133 +0,0 @@
-import type { ProcedureError } from './errors.js'
-import type { TJSONSchema } from './schema/types.js'
-
-export type TNoContextProvided = unknown
-
-export type TLocalContext = {
-  error: (message: string, meta?: object) => ProcedureError
-  signal?: AbortSignal
-}
-
-export type TStreamContext = TLocalContext & {
-  signal: AbortSignal
-}
-
-/**
- * Discriminant on every procedure registration that drives builder routing.
- *
- * - `'rpc'` — Create() registration
- * - `'rpc-stream'` — CreateStream() registration
- * - `'http'` — CreateHttp() registration
- * - `'http-stream'` — CreateHttpStream() registration
- *
- * `HonoAppBuilder` dispatches all four kinds from a single registration. Use
- * `kind` for any logic that needs to distinguish procedure shape; the legacy
- * `isStream` field on TStreamProcedureRegistration is kept for back-compat but
- * new code should branch on `kind`.
- */
-export type ProcedureKind = 'rpc' | 'rpc-stream' | 'http' | 'http-stream'
-
-export type TProcedureRegistration<TContext = unknown, TExtendedConfig = unknown> = {
-  name: string
-  kind: 'rpc'
-  config: {
-    description?: string
-    schema?: {
-      params?: TJSONSchema
-      returnType?: TJSONSchema
-    }
-    validation?: {
-      params?: (params: any) => { errors?: any[] }
-    }
-  } & TExtendedConfig
-  handler: (ctx: TContext, params?: any) => Promise<any>
-}
-
-export type TStreamProcedureRegistration<TContext = unknown, TExtendedConfig = unknown> = {
-  name: string
-  kind: 'rpc-stream'
-  isStream: true
-  config: {
-    description?: string
-    schema?: {
-      params?: TJSONSchema
-      yieldType?: TJSONSchema
-      returnType?: TJSONSchema
-    }
-    validation?: {
-      params?: (params: any) => { errors?: any[] }
-      yield?: (value: any) => { errors?: any[] }
-    }
-    validateYields?: boolean
-  } & TExtendedConfig
-  handler: (ctx: TContext, params?: any) => AsyncGenerator<any, any, unknown>
-}
-
-export type TBuilderConfig = {
-  /**
-   * Skip per-call AJV runtime validation. JSON Schema is still computed at
-   * registration time. Intended for trusted internal factories whose callers
-   * are already type-checked at build time.
-   */
-  noRuntimeValidation?: true
-}
-
-export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
-
-export type TCreateHttpConfig<TReq, TRes, TErrorKey extends string = string> = {
-  path: string
-  method: HttpMethod
-  successStatus?: number
-  scope?: string
-  errors?: TErrorKey[]
-  description?: string
-  schema: {
-    req?: TReq
-    res?: TRes
-  }
-}
-
-export type THttpProcedureRegistration<TContext = unknown> = {
-  name: string
-  kind: 'http'
-  config: {
-    path: string
-    method: HttpMethod
-    successStatus?: number
-    scope?: string
-    errors?: string[]
-    description?: string
-    schema?: {
-      req?: Record<string, TJSONSchema>
-      res?: { body?: TJSONSchema; headers?: TJSONSchema }
-    }
-    validation?: {
-      req?: Record<string, (value: any) => { errors?: any[] }>
-    }
-  }
-  handler: (ctx: TContext, req?: any) => Promise<any>
-}
-
-export type THttpStreamProcedureRegistration<TContext = unknown> = {
-  name: string
-  kind: 'http-stream'
-  config: {
-    path: string
-    method: HttpMethod
-    scope?: string
-    errors?: string[]
-    description?: string
-    schema?: {
-      req?: Record<string, TJSONSchema>
-      res?: { headers?: TJSONSchema }
-      yield?: TJSONSchema
-      returnType?: TJSONSchema
-    }
-    validation?: {
-      req?: Record<string, (value: any) => { errors?: any[] }>
-      yield?: (value: any) => { errors?: any[] }
-    }
-    validateYields?: boolean
-  }
-  handler: (ctx: TContext, req?: any) => Promise<{ stream: AsyncGenerator<any, any, unknown>; initialHeaders?: Record<string, string> }>
-}