ts-procedures 5.3.0 → 5.4.1

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,148 +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 }
-  validation: {
-    params?: (params: any) => { errors?: TSchemaValidationError[] }
-    yield?: (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 },
-  onParseError: (errors: { params?: string; returnType?: string; yieldType?: 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 {}
-      }
-    }
-  }
-
-  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()
-    })
-  })
-})

package/src/stack-utils.ts

@@ -1,129 +0,0 @@
-/**
- * Represents a specific location in source code where a procedure was defined.
- */
-export type DefinitionLocation = {
-  file: string
-  line: number
-  column: number
-  raw: string
-}
-
-/**
- * Contains information about where a procedure was defined.
- */
-export type DefinitionInfo = {
-  definedAt?: DefinitionLocation
-  definitionStack?: string
-}
-
-/**
- * Internal ts-procedures files that should be skipped when finding user code.
- * Only skip the core library files, not test files or user code.
- */
-const INTERNAL_FILES = [
-  '/index.ts',
-  '/index.js',
-  '/errors.ts',
-  '/errors.js',
-  '/stack-utils.ts',
-  '/stack-utils.js',
-  '/compute-schema.ts',
-  '/compute-schema.js',
-  '/parser.ts',
-  '/parser.js',
-]
-
-/**
- * Captures the stack trace at the call site and extracts the definition location.
- * Finds the first stack frame outside of ts-procedures internal files.
- */
-export function captureDefinitionInfo(): DefinitionInfo {
-  const err = new Error()
-  const stack = err.stack
-
-  if (!stack) {
-    return {}
-  }
-
-  const lines = stack.split('\n')
-
-  // Find the first frame that's not from ts-procedures internals
-  // Skip the first line (Error message) and frames from this module
-  let userFrame: string | undefined
-
-  for (let i = 1; i < lines.length; i++) {
-    const rawLine = lines[i]
-    if (!rawLine) continue
-    const line = rawLine.trim()
-
-    // Skip empty or invalid frames
-    if (!line.startsWith('at ')) {
-      continue
-    }
-
-    // Skip frames from ts-procedures internal source files
-    const isInternalFile = INTERNAL_FILES.some(file => line.includes(file))
-    if (isInternalFile) {
-      continue
-    }
-
-    // Skip frames from ts-procedures in node_modules (when used as a dependency)
-    if (line.includes('/node_modules/ts-procedures/') || line.includes('\\node_modules\\ts-procedures\\')) {
-      continue
-    }
-
-    // Skip internal node frames
-    if (line.includes('node:') || line.startsWith('at Module.') || line.startsWith('at Object.<anonymous> (node:')) {
-      continue
-    }
-
-    userFrame = line
-    break
-  }
-
-  if (!userFrame) {
-    return { definitionStack: stack }
-  }
-
-  const definedAt = parseStackFrame(userFrame)
-
-  return {
-    definedAt,
-    definitionStack: stack,
-  }
-}
-
-/**
- * Parses a V8 stack frame line to extract file, line, and column info.
- * Handles formats like:
- * - "at Object.<anonymous> (/path/to/file.ts:10:5)"
- * - "at functionName (/path/to/file.ts:10:5)"
- * - "at /path/to/file.ts:10:5"
- */
-function parseStackFrame(frame: string): DefinitionLocation | undefined {
-  // Match patterns like "(path:line:column)" or just "path:line:column"
-  const match = frame.match(/\(([^)]+):(\d+):(\d+)\)$/) || frame.match(/at ([^:]+):(\d+):(\d+)$/)
-
-  if (match && match[1] && match[2] && match[3]) {
-    return {
-      file: match[1],
-      line: parseInt(match[2], 10),
-      column: parseInt(match[3], 10),
-      raw: frame,
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Formats definition info for appending to error stacks.
- */
-export function formatDefinitionInfo(info: DefinitionInfo, procedureName: string): string | undefined {
-  if (!info.definedAt) {
-    return undefined
-  }
-
-  const { file, line, column } = info.definedAt
-  return `\n--- Procedure "${procedureName}" defined at ---\n    at ${file}:${line}:${column}`
-}