ts-procedures 5.4.0 → 5.5.0

package/src/schema/compute-schema.ts

@@ -1,88 +0,0 @@
-import { schemaParser, TSchemaValidationError } from './parser.js'
-import { ProcedureRegistrationError } from '../errors.js'
-import { TJSONSchema } from './types.js'
-import { DefinitionInfo } from '../stack-utils.js'
-
-/**
- * This function is used to compute the JSON schema and validation functions
- * for a given schema.
- *
- * @param name The name of the procedure
- * @param schema Procedure schema
- * @param definitionInfo Optional definition info for error reporting
- */
-export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType, TYieldTypeSchemaType = unknown>(
-  name: string,
-  schema?: {
-    params?: TParamsSchemaType
-    returnType?: TReturnTypeSchemaType
-    yieldType?: TYieldTypeSchemaType
-    input?: Record<string, unknown>
-  },
-  // Used for error stack trace details
-  definitionInfo?: DefinitionInfo
-): {
-  jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    input?: Record<string, TJSONSchema>
-  }
-  validations: {
-    params?: (params?: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value?: any) => { errors?: TSchemaValidationError[] }
-    input?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
-  }
-} {
-  const jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    input?: Record<string, TJSONSchema>
-  } = {
-    params: undefined,
-    returnType: undefined,
-    yieldType: undefined,
-    input: undefined,
-  }
-
-  const validations: {
-    params?: (params?: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value?: any) => { errors?: TSchemaValidationError[] }
-    input?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
-  } = {}
-
-  // Mutual exclusivity: params and input cannot both be defined
-  if (schema?.params && schema?.input) {
-    throw new ProcedureRegistrationError(
-      name,
-      `schema.params and schema.input are mutually exclusive for procedure "${name}". Use schema.params for flat input or schema.input for structured multi-channel input.`,
-      definitionInfo
-    )
-  }
-
-  if (schema) {
-    const {
-      jsonSchema: { params, returnType, yieldType, input },
-      validation,
-    } = schemaParser(schema, (errors) => {
-      throw new ProcedureRegistrationError(
-        name,
-        `Error parsing schema for ${name} - ${Object.entries(errors)
-          .map(([key, error]) => `${key}: ${error}`)
-          .join(', ')}`,
-        definitionInfo
-      )
-    })
-
-    jsonSchema.params = params
-    jsonSchema.returnType = returnType
-    jsonSchema.yieldType = yieldType
-    jsonSchema.input = input
-    validations.params = validation.params
-    validations.yield = validation.yield
-    validations.input = validation.input
-  }
-
-  return { jsonSchema, validations }
-}

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 { 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,215 +0,0 @@
-import { default as addFormats } from 'ajv-formats'
-import * as AJV from 'ajv'
-import { extractJsonSchema } from './extract-json-schema.js'
-import { TJSONSchema } from './types.js'
-
-export type TSchemaParsed = {
-  jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    input?: Record<string, TJSONSchema>
-  }
-  validation: {
-    params?: (params: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value: any) => { errors?: TSchemaValidationError[] }
-    input?: 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; input?: Record<string, 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.input) {
-    jsonSchema.input = {}
-    validation.input = {}
-
-    for (const [channelName, channelSchema] of Object.entries(schema.input)) {
-      if (!channelSchema) continue
-
-      let channelJsonSchema: TJSONSchema | undefined
-
-      try {
-        const extracted = extractJsonSchema(channelSchema as TJSONSchema)
-        if (extracted) {
-          channelJsonSchema = extracted
-          jsonSchema.input[channelName] = extracted
-        }
-      } catch (e: any) {
-        onParseError({
-          [`input.${channelName}`]: `Error extracting json schema schema.input.${channelName} - ${e.message}`,
-        })
-      }
-
-      if (!channelJsonSchema) {
-        onParseError({
-          [`input.${channelName}`]: `Error extracting json schema schema.input.${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({
-            [`input.${channelName}`]: `Error compiling schema.input.${channelName} for validator - ${e.message}`,
-          })
-        }
-
-        validation.input[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 {}
-        }
-      }
-    }
-  }
-
-  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 { CoreValidator } from 'suretype'
-import { 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 { CoreValidator, TypeOf } from 'suretype'
-import { 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/stack-utils.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { captureDefinitionInfo, formatDefinitionInfo, DefinitionInfo } from './stack-utils.js'
-
-describe('Stack Utils', () => {
-  describe('captureDefinitionInfo', () => {
-    test('returns definition info with definedAt', () => {
-      const info = captureDefinitionInfo()
-
-      // Should capture the call site in this test file
-      expect(info).toBeDefined()
-      expect(info.definitionStack).toBeDefined()
-      expect(typeof info.definitionStack).toBe('string')
-    })
-
-    test('definedAt contains file, line, column when available', () => {
-      const info = captureDefinitionInfo()
-
-      // The definedAt should be present since we're calling from user code (test file)
-      if (info.definedAt) {
-        expect(info.definedAt.file).toBeDefined()
-        expect(typeof info.definedAt.file).toBe('string')
-        expect(info.definedAt.line).toBeDefined()
-        expect(typeof info.definedAt.line).toBe('number')
-        expect(info.definedAt.line).toBeGreaterThan(0)
-        expect(info.definedAt.column).toBeDefined()
-        expect(typeof info.definedAt.column).toBe('number')
-        expect(info.definedAt.column).toBeGreaterThan(0)
-        expect(info.definedAt.raw).toBeDefined()
-        expect(typeof info.definedAt.raw).toBe('string')
-      }
-    })
-
-    test('definitionStack contains Error stack trace', () => {
-      const info = captureDefinitionInfo()
-
-      expect(info.definitionStack).toContain('Error')
-      expect(info.definitionStack).toContain('at ')
-    })
-  })
-
-  describe('formatDefinitionInfo', () => {
-    test('returns undefined when definedAt is not present', () => {
-      const info: DefinitionInfo = {}
-      const result = formatDefinitionInfo(info, 'TestProcedure')
-
-      expect(result).toBeUndefined()
-    })
-
-    test('returns formatted string when definedAt is present', () => {
-      const info: DefinitionInfo = {
-        definedAt: {
-          file: '/app/procedures/test.ts',
-          line: 42,
-          column: 5,
-          raw: 'at Object.<anonymous> (/app/procedures/test.ts:42:5)',
-        },
-      }
-      const result = formatDefinitionInfo(info, 'TestProcedure')
-
-      expect(result).toBeDefined()
-      expect(result).toContain('--- Procedure "TestProcedure" defined at ---')
-      expect(result).toContain('/app/procedures/test.ts:42:5')
-    })
-
-    test('includes procedure name in formatted output', () => {
-      const info: DefinitionInfo = {
-        definedAt: {
-          file: '/path/to/file.ts',
-          line: 10,
-          column: 3,
-          raw: 'at /path/to/file.ts:10:3',
-        },
-      }
-      const result = formatDefinitionInfo(info, 'MyCustomProcedure')
-
-      expect(result).toContain('"MyCustomProcedure"')
-    })
-  })
-
-  describe('integration with procedure creation', () => {
-    test('captures location from calling code', () => {
-      // Helper to simulate what happens in Create()
-      function simulateCreate() {
-        return captureDefinitionInfo()
-      }
-
-      const info = simulateCreate()
-
-      // Should have captured the location of the simulateCreate() call
-      expect(info).toBeDefined()
-      expect(info.definitionStack).toBeDefined()
-    })
-  })
-})