ts-procedures 1.0.0

package/src/schema/compute-schema.ts

@@ -0,0 +1,55 @@
+import { schemaParser, TSchemaValidationError } from './parser.js'
+import { ProcedureRegistrationError } from '../errors.js'
+import { TJSONSchema } from './types.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
+ */
+export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType>(
+  name: string,
+  schema?: {
+    params?: TParamsSchemaType
+    returnType?: TReturnTypeSchemaType
+  },
+): {
+  jsonSchema: {
+    params?: TJSONSchema
+    returnType?: TJSONSchema
+  }
+  validations: {
+    params?: (params?: any) => { errors?: TSchemaValidationError[] }
+  }
+} {
+  const jsonSchema: { params?: TJSONSchema; returnType?: TJSONSchema } = {
+    params: undefined,
+    returnType: undefined,
+  }
+
+  const validations: {
+    params?: (params?: any) => { errors?: TSchemaValidationError[] }
+  } = {}
+
+  if (schema) {
+    const {
+      jsonSchema: { params, returnType },
+      validation,
+    } = schemaParser(schema, (errors) => {
+      throw new ProcedureRegistrationError(
+        name,
+        `Error parsing schema for ${name} - ${Object.entries(errors)
+          .map(([key, error]) => `${key}: ${error}`)
+          .join(', ')}`,
+      )
+    })
+
+    jsonSchema.params = params
+    jsonSchema.returnType = returnType
+    validations.params = validation.params
+  }
+
+  return { jsonSchema, validations }
+}

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,156 @@
+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'/)
+  })
+})

package/src/schema/parser.ts

@@ -0,0 +1,92 @@
+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 }
+  validation: { params?: (params: any) => { errors?: TSchemaValidationError[] } }
+}
+
+export type TSchemaValidationError = AJV.ErrorObject
+
+// @ts-ignore
+const ajv = addFormats(
+  new AJV.Ajv({
+    allErrors: true,
+    coerceTypes: true,
+    removeAdditional: true,
+  }),
+)
+
+export function schemaParser(
+  schema: { params?: unknown; returnType?: unknown },
+  onParseError: (errors: { params?: string; returnType?: 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
+
+      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) => {
+        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`,
+      })
+    }
+  }
+
+  return { jsonSchema, validation }
+}

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/ban-types */
+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
+
+export type TJSONSchema = Record<string, any>
+
+export type Prettify<TObject> = {
+  [Key in keyof TObject]: TObject[Key]
+} & {}