tjs-lang 0.6.44 → 0.7.3

package/src/lang/json-schema.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect } from 'bun:test'
+import {
+  typeDescriptorToJSONSchema,
+  exampleToJSONSchema,
+  functionMetaToJSONSchema,
+} from './json-schema'
+// Also used directly in tests below
+import type { TypeDescriptor } from './types'
+import { Type, TString, TInteger } from '../types/Type'
+import { tjs } from './index'
+import { createRuntime, installRuntime } from './runtime'
+
+describe('json-schema', () => {
+  describe('typeDescriptorToJSONSchema', () => {
+    it('handles primitives', () => {
+      expect(typeDescriptorToJSONSchema({ kind: 'string' })).toEqual({
+        type: 'string',
+      })
+      expect(typeDescriptorToJSONSchema({ kind: 'number' })).toEqual({
+        type: 'number',
+      })
+      expect(typeDescriptorToJSONSchema({ kind: 'integer' })).toEqual({
+        type: 'integer',
+      })
+      expect(typeDescriptorToJSONSchema({ kind: 'boolean' })).toEqual({
+        type: 'boolean',
+      })
+      expect(typeDescriptorToJSONSchema({ kind: 'null' })).toEqual({
+        type: 'null',
+      })
+    })
+
+    it('handles non-negative-integer', () => {
+      expect(
+        typeDescriptorToJSONSchema({ kind: 'non-negative-integer' })
+      ).toEqual({ type: 'integer', minimum: 0 })
+    })
+
+    it('handles any and undefined', () => {
+      expect(typeDescriptorToJSONSchema({ kind: 'any' })).toEqual({})
+      expect(typeDescriptorToJSONSchema({ kind: 'undefined' })).toEqual({})
+    })
+
+    it('handles arrays', () => {
+      expect(
+        typeDescriptorToJSONSchema({
+          kind: 'array',
+          items: { kind: 'string' },
+        })
+      ).toEqual({ type: 'array', items: { type: 'string' } })
+    })
+
+    it('handles objects', () => {
+      const td: TypeDescriptor = {
+        kind: 'object',
+        shape: {
+          name: { kind: 'string' },
+          age: { kind: 'integer' },
+        },
+      }
+      expect(typeDescriptorToJSONSchema(td)).toEqual({
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+        },
+        required: ['name', 'age'],
+        additionalProperties: false,
+      })
+    })
+
+    it('handles nullable', () => {
+      expect(
+        typeDescriptorToJSONSchema({ kind: 'string', nullable: true })
+      ).toEqual({ anyOf: [{ type: 'string' }, { type: 'null' }] })
+    })
+
+    it('handles unions', () => {
+      expect(
+        typeDescriptorToJSONSchema({
+          kind: 'union',
+          members: [{ kind: 'string' }, { kind: 'integer' }],
+        })
+      ).toEqual({ anyOf: [{ type: 'string' }, { type: 'integer' }] })
+    })
+
+    it('handles nested objects', () => {
+      const td: TypeDescriptor = {
+        kind: 'object',
+        shape: {
+          user: {
+            kind: 'object',
+            shape: { name: { kind: 'string' } },
+          },
+          tags: {
+            kind: 'array',
+            items: { kind: 'string' },
+          },
+        },
+      }
+      const schema = typeDescriptorToJSONSchema(td)
+      expect(schema.properties?.user).toEqual({
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+        additionalProperties: false,
+      })
+      expect(schema.properties?.tags).toEqual({
+        type: 'array',
+        items: { type: 'string' },
+      })
+    })
+  })
+
+  describe('exampleToJSONSchema', () => {
+    it('infers from primitive examples', () => {
+      expect(exampleToJSONSchema('hello')).toEqual({ type: 'string' })
+      expect(exampleToJSONSchema(42)).toEqual({ type: 'integer' })
+      expect(exampleToJSONSchema(3.14)).toEqual({ type: 'number' })
+      expect(exampleToJSONSchema(true)).toEqual({ type: 'boolean' })
+      expect(exampleToJSONSchema(null)).toEqual({ type: 'null' })
+    })
+
+    it('infers from object examples', () => {
+      expect(exampleToJSONSchema({ name: '', age: 0 })).toEqual({
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+        },
+        required: ['name', 'age'],
+        additionalProperties: false,
+      })
+    })
+
+    it('infers from array examples', () => {
+      expect(exampleToJSONSchema(['hello'])).toEqual({
+        type: 'array',
+        items: { type: 'string' },
+      })
+      expect(exampleToJSONSchema([])).toEqual({ type: 'array' })
+    })
+  })
+
+  describe('RuntimeType.toJSONSchema', () => {
+    it('generates schema from example-based types', () => {
+      const User = Type('user', { name: '', age: 0 })
+      const schema = User.toJSONSchema()
+      expect(schema.type).toBe('object')
+      expect(schema.properties?.name).toEqual({ type: 'string' })
+      expect(schema.properties?.age).toEqual({ type: 'integer' })
+    })
+
+    it('generates schema for predicate-only types', () => {
+      const schema = TString.toJSONSchema()
+      // Predicate-only types have no example or schema, just description
+      expect(schema.description).toBe('string')
+    })
+
+    it('generates schema from simple types', () => {
+      const Name = Type('name', 'Alice')
+      const schema = Name.toJSONSchema()
+      expect(schema.type).toBe('string')
+    })
+  })
+
+  describe('RuntimeType.strip', () => {
+    it('strips extra fields from objects', () => {
+      const User = Type('user', { name: '', age: 0 })
+      const input = { name: 'Alice', age: 30, secret: 'password' }
+      const stripped = User.strip(input) as any
+      expect(stripped.name).toBe('Alice')
+      expect(stripped.age).toBe(30)
+      expect(stripped.secret).toBeUndefined()
+    })
+
+    it('returns value as-is for predicate-only types', () => {
+      const result = TString.strip('hello')
+      expect(result).toBe('hello')
+    })
+  })
+
+  describe('functionMetaToJSONSchema', () => {
+    it('generates input/output schema from function metadata', () => {
+      const meta = {
+        params: {
+          name: {
+            type: { kind: 'string' as const },
+            required: true,
+            example: 'Alice',
+          },
+          age: {
+            type: { kind: 'integer' as const },
+            required: true,
+            example: 0,
+          },
+        },
+        returns: {
+          type: {
+            kind: 'object' as const,
+            shape: { id: { kind: 'integer' as const } },
+          },
+        },
+      }
+
+      const { input, output } = functionMetaToJSONSchema(meta)
+      expect(input.type).toBe('object')
+      expect(input.properties?.name).toEqual({
+        type: 'string',
+        examples: ['Alice'],
+      })
+      expect(input.required).toContain('name')
+      expect(input.required).toContain('age')
+      expect(output?.type).toBe('object')
+    })
+  })
+
+  describe('fn.__tjs.schema() on transpiled functions', () => {
+    const savedTjs = globalThis.__tjs
+
+    it('provides schema via functionMetaToJSONSchema on emitted metadata', () => {
+      const runtime = createRuntime()
+      try {
+        globalThis.__tjs = runtime
+        const result = tjs(`function greet(name: 'World'): 'Hello, World' {
+  return 'Hello, ' + name
+}`)
+        const fn = new Function(result.code + '\nreturn greet')()
+        expect(fn.__tjs).toBeDefined()
+        // Use standalone function on the metadata
+        const { input, output } = functionMetaToJSONSchema(fn.__tjs)
+        expect(input.type).toBe('object')
+        expect(input.properties?.name?.type).toBe('string')
+        expect(output?.type).toBe('string')
+      } finally {
+        globalThis.__tjs = savedTjs
+      }
+    })
+
+    it('provides schema via .schema() when wrap() is used', () => {
+      const runtime = createRuntime()
+      try {
+        globalThis.__tjs = runtime
+        installRuntime()
+        const result = tjs(`function greet(name: 'World'): 'Hello, World' {
+  return 'Hello, ' + name
+}`)
+        const fn = new Function(result.code + '\nreturn greet')()
+        // After installRuntime(), wrap() should have attached .schema()
+        if (typeof fn.__tjs.schema === 'function') {
+          const { input, output } = fn.__tjs.schema()
+          expect(input.type).toBe('object')
+          expect(input.properties?.name?.type).toBe('string')
+          expect(output?.type).toBe('string')
+        }
+      } finally {
+        globalThis.__tjs = savedTjs
+      }
+    })
+  })
+})

package/src/lang/json-schema.ts

@@ -0,0 +1,167 @@
+/**
+ * JSON Schema generation from TJS TypeDescriptors and example values
+ *
+ * Converts TJS type information into standard JSON Schema (draft 2020-12).
+ */
+
+import type { TypeDescriptor } from './types'
+
+export interface JSONSchemaObject {
+  type?: string | string[]
+  properties?: Record<string, JSONSchemaObject>
+  items?: JSONSchemaObject | JSONSchemaObject[]
+  required?: string[]
+  additionalProperties?: boolean
+  anyOf?: JSONSchemaObject[]
+  minimum?: number
+  examples?: unknown[]
+  description?: string
+  [key: string]: unknown
+}
+
+/**
+ * Convert a TypeDescriptor to JSON Schema
+ */
+export function typeDescriptorToJSONSchema(
+  td: TypeDescriptor
+): JSONSchemaObject {
+  if (td.nullable) {
+    const base = typeDescriptorToJSONSchema({ ...td, nullable: false })
+    return { anyOf: [base, { type: 'null' }] }
+  }
+
+  switch (td.kind) {
+    case 'string':
+      return { type: 'string' }
+    case 'number':
+      return { type: 'number' }
+    case 'integer':
+      return { type: 'integer' }
+    case 'non-negative-integer':
+      return { type: 'integer', minimum: 0 }
+    case 'boolean':
+      return { type: 'boolean' }
+    case 'null':
+      return { type: 'null' }
+    case 'undefined':
+      return {}
+    case 'any':
+      return {}
+    case 'array':
+      if (td.items) {
+        return { type: 'array', items: typeDescriptorToJSONSchema(td.items) }
+      }
+      return { type: 'array' }
+    case 'object':
+      if (td.shape) {
+        const properties: Record<string, JSONSchemaObject> = {}
+        const required: string[] = []
+        for (const [key, fieldTd] of Object.entries(td.shape)) {
+          properties[key] = typeDescriptorToJSONSchema(fieldTd)
+          required.push(key)
+        }
+        return {
+          type: 'object',
+          properties,
+          required,
+          additionalProperties: false,
+        }
+      }
+      return { type: 'object' }
+    case 'union':
+      if (td.members) {
+        return { anyOf: td.members.map(typeDescriptorToJSONSchema) }
+      }
+      return {}
+    default:
+      return {}
+  }
+}
+
+/**
+ * Infer a JSON Schema from an example value (without going through TypeDescriptor)
+ */
+export function exampleToJSONSchema(value: unknown): JSONSchemaObject {
+  if (value === null) return { type: 'null' }
+  if (value === undefined) return {}
+
+  switch (typeof value) {
+    case 'string':
+      return { type: 'string' }
+    case 'number':
+      return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' }
+    case 'boolean':
+      return { type: 'boolean' }
+    case 'object': {
+      if (Array.isArray(value)) {
+        if (value.length === 0) return { type: 'array' }
+        // Infer item type from first element
+        return { type: 'array', items: exampleToJSONSchema(value[0]) }
+      }
+      // Object
+      const properties: Record<string, JSONSchemaObject> = {}
+      const required: string[] = []
+      for (const [key, val] of Object.entries(
+        value as Record<string, unknown>
+      )) {
+        properties[key] = exampleToJSONSchema(val)
+        required.push(key)
+      }
+      return {
+        type: 'object',
+        properties,
+        required,
+        additionalProperties: false,
+      }
+    }
+    default:
+      return {}
+  }
+}
+
+/**
+ * Generate JSON Schema for function parameters (as an object schema)
+ * and return type from __tjs metadata
+ */
+export function functionMetaToJSONSchema(meta: {
+  params: Record<string, any>
+  returns?: { type: any; example?: any }
+}): { input: JSONSchemaObject; output?: JSONSchemaObject } {
+  const properties: Record<string, JSONSchemaObject> = {}
+  const required: string[] = []
+
+  for (const [name, paramInfo] of Object.entries(meta.params)) {
+    if (paramInfo?.type?.kind) {
+      // Has TypeDescriptor
+      properties[name] = typeDescriptorToJSONSchema(paramInfo.type)
+    } else if (paramInfo?.example !== undefined) {
+      // Has example value
+      properties[name] = exampleToJSONSchema(paramInfo.example)
+    } else {
+      properties[name] = {}
+    }
+    if (paramInfo?.required !== false) {
+      required.push(name)
+    }
+    if (paramInfo?.example !== undefined) {
+      properties[name].examples = [paramInfo.example]
+    }
+  }
+
+  const input: JSONSchemaObject = {
+    type: 'object',
+    properties,
+    required,
+  }
+
+  let output: JSONSchemaObject | undefined
+  if (meta.returns) {
+    if (meta.returns.type?.kind) {
+      output = typeDescriptorToJSONSchema(meta.returns.type)
+    } else if (meta.returns.example !== undefined) {
+      output = exampleToJSONSchema(meta.returns.example)
+    }
+  }
+
+  return { input, output }
+}

package/src/lang/parser-params.ts

@@ -307,34 +307,28 @@ export function transformParenExpressions(
       const processedParams = processParamString(params, ctx, true)
       result += processedParams + ')'
 
-      // Check what follows the closing paren: whitespace then -> or -? or -! (return type)
+      // Check what follows the closing paren: return type annotation (:, :?, :!)
       let j = i
       while (j < source.length && /\s/.test(source[j])) j++
 
-      const returnArrow = source.slice(j, j + 2)
-      if (
-        returnArrow === '->' ||
-        returnArrow === '-?' ||
-        returnArrow === '-!'
-      ) {
-        // Extract return type
-        j += 2
-        // Skip whitespace after arrow
+      if (source[j] === ':') {
+        const colonMarker = source.slice(j, j + 2)
+        let safety: 'safe' | 'unsafe' | undefined
+        if (colonMarker === ':?' || colonMarker === ':!') {
+          j += 2
+          safety = colonMarker === ':?' ? 'safe' : 'unsafe'
+        } else {
+          j += 1
+        }
         while (j < source.length && /\s/.test(source[j])) j++
 
         const typeResult = extractReturnTypeValue(source, j)
         if (typeResult) {
-          const { type, endPos: typeEnd } = typeResult
-          // Record first return type for metadata
           if (firstReturnType === undefined) {
-            firstReturnType = type
-            if (returnArrow === '-?') {
-              firstReturnSafety = 'safe'
-            } else if (returnArrow === '-!') {
-              firstReturnSafety = 'unsafe'
-            }
+            firstReturnType = typeResult.type
+            if (safety) firstReturnSafety = safety
           }
-          i = typeEnd
+          i = typeResult.endPos
         }
       }
       continue
@@ -398,27 +392,17 @@ export function transformParenExpressions(
       const processedParams = processParamString(params, ctx, true)
       result += processedParams + ')'
 
-      // Check for return type annotation: ) -> type, ) -! type, ) -? type, ): type
+      // Check for return type annotation: ): type, ):! type, ):? type
       let j = i
       while (j < source.length && /\s/.test(source[j])) j++
 
-      // Handle ->, -!, -? return type (TJS style)
-      const returnArrow = source.slice(j, j + 2)
-      if (
-        returnArrow === '->' ||
-        returnArrow === '-!' ||
-        returnArrow === '-?'
-      ) {
-        j += 2
-        while (j < source.length && /\s/.test(source[j])) j++
-        const typeResult = extractReturnTypeValue(source, j)
-        if (typeResult) {
-          i = typeResult.endPos
+      if (source[j] === ':') {
+        const colonMarker = source.slice(j, j + 2)
+        if (colonMarker === ':?' || colonMarker === ':!') {
+          j += 2
+        } else {
+          j++
         }
-      }
-      // Handle : return type (TS style) - just strip it
-      else if (source[j] === ':') {
-        j++
         while (j < source.length && /\s/.test(source[j])) j++
         const typeResult = extractReturnTypeValue(source, j)
         if (typeResult) {
@@ -448,15 +432,15 @@ export function transformParenExpressions(
       let j = endPos
       while (j < source.length && /\s/.test(source[j])) j++
 
-      // Check for return type annotation on arrow function: ) -> type =>
+      // Check for return type annotation on arrow function: ): type =>
       let arrowReturnType: string | undefined
-      const returnArrow = source.slice(j, j + 2)
-      if (
-        returnArrow === '->' ||
-        returnArrow === '-?' ||
-        returnArrow === '-!'
-      ) {
-        j += 2
+      if (source[j] === ':') {
+        const colonMarker = source.slice(j, j + 2)
+        if (colonMarker === ':?' || colonMarker === ':!') {
+          j += 2
+        } else {
+          j++
+        }
         while (j < source.length && /\s/.test(source[j])) j++
         const typeResult = extractReturnTypeValue(source, j)
         if (typeResult) {