ts-procedures 8.5.0 → 9.0.0

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()
-  })
-})

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]
-} & {}