@archtx/procedures 1.1.7 → 1.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archtx/procedures",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Procedure generator for @archtx",
   "main": "dist/exports.js",
   "types": "dist/exports.d.ts",
@@ -21,7 +21,8 @@
   "license": "MIT",
   "files": [
     "assets",
-    "dist"
+    "dist",
+    "src"
   ],
   "dependencies": {
     "ajv": "^8.17.1",

package/src/errors.ts

@@ -0,0 +1,54 @@
+import { TSchemaValidationError } from './schema/parser.js'
+import { ProcedureCodes } from './procedure-codes.js'
+
+export class ProcedureError extends Error {
+  constructor(
+    readonly procedureName: string,
+    readonly code: ProcedureCodes & number,
+    readonly message: string,
+    readonly meta?: object,
+  ) {
+    super(message)
+    this.name = 'ProcedureError'
+
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    Object.setPrototypeOf(this, ProcedureError.prototype)
+  }
+}
+
+export class ProcedureHookError extends ProcedureError {
+  constructor(
+    readonly procedureName: string,
+    message: string,
+  ) {
+    super(procedureName, ProcedureCodes.PRECONDITION_FAILED, message)
+    this.name = 'ProcedureHookError'
+
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    Object.setPrototypeOf(this, ProcedureHookError.prototype)
+  }
+}
+
+export class ProcedureValidationError extends ProcedureError {
+  constructor(
+    readonly procedureName: string,
+    message: string,
+    readonly errors?: TSchemaValidationError[],
+  ) {
+    super(procedureName, ProcedureCodes.VALIDATION_ERROR, message)
+    this.name = 'ProcedureValidationError'
+
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    Object.setPrototypeOf(this, ProcedureValidationError.prototype)
+  }
+}
+
+export class ProcedureRegistrationError extends Error {
+  constructor(readonly procedureName: string, message: string) {
+    super(message)
+    this.name = 'ProcedureRegistrationError'
+
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    Object.setPrototypeOf(this, ProcedureRegistrationError.prototype)
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,442 @@
+import { describe, expect, test } from 'vitest'
+import { Procedures } from './index.js'
+import { v } from 'suretype'
+import {
+  ProcedureHookError,
+  ProcedureError,
+  ProcedureValidationError,
+} from './errors.js'
+import { ProcedureCodes } from './procedure-codes.js'
+
+describe('Procedures', () => {
+  test('Procedures', () => {
+    const result = Procedures({
+      onCreate: () => {
+        return undefined
+      },
+    })
+
+    expect(result).toHaveProperty('Create')
+  })
+
+  test('Create Single Procedures', () => {
+    const { test1, test1_Info } = Procedures().Create(
+      'test1',
+      {},
+      async (ctx, args) => {
+        return '1'
+      },
+    )
+    const { test2, test2_Info } = Procedures().Create(
+      'test2',
+      {},
+      async (ctx, args) => {
+        return '2'
+      },
+    )
+
+    expect(test1).toBeDefined()
+    expect(test1_Info).toBeDefined()
+    expect(test2).toBeDefined()
+    expect(test2_Info).toBeDefined
+  })
+
+  test('Procedures - Create call', () =>
+    new Promise<void>((done) => {
+      let mockHttpCall: any
+
+      const { Create } = Procedures({
+        onCreate: ({ handler, config, name }) => {
+          mockHttpCall = handler
+        },
+      })
+
+      Create(
+        'Handler',
+        {
+          schema: {
+            args: v.object({ name: v.string() }),
+            data: v.string(),
+          },
+        },
+        async (ctx, args) => {
+          expect(args).toEqual({ name: 'name' })
+          done()
+          return 'name'
+        },
+      )
+
+      mockHttpCall({}, { name: 'name' })
+    }))
+
+  test('Procedures - Create returns a handler to call/test the Procedure registration', async () => {
+    let ProcedureRegisteredCbHandler: any
+
+    const { Create } = Procedures({
+      onCreate: (Procedure) => {
+        ProcedureRegisteredCbHandler = Procedure.handler
+      },
+    })
+
+    const { Handler, Handler_Info } = Create(
+      'Handler',
+      {
+        description: 'Handler description',
+        schema: {
+          args: v.object({ number: v.number() }),
+        },
+      },
+      async (ctx, args) => {
+        return args.number
+      },
+    )
+
+    expect(Handler).toBeDefined()
+    expect(ProcedureRegisteredCbHandler).toEqual(Handler)
+
+    const result = Handler({}, { number: 1 })
+
+    expect(result).toBeDefined()
+    expect(result).toBeInstanceOf(Promise)
+    await expect(result).resolves.toEqual(1)
+
+    expect(Handler_Info).toBeDefined()
+    expect(Handler_Info).toBeInstanceOf(Object)
+    expect(Handler_Info.schema).toHaveProperty('args')
+    expect(Handler_Info.schema.args).toEqual({
+      type: 'object',
+      properties: { number: { type: 'number' } },
+    })
+    expect(Handler_Info).toHaveProperty('description')
+    expect(Handler_Info.description).toEqual('Handler description')
+  })
+
+  test('Procedures - Create args validation w/ no args provided', () =>
+    new Promise<void>((done) => {
+      let mockHttpCall: any
+
+      const { Create } = Procedures({
+        onCreate: ({ handler, config, name }) => {
+          mockHttpCall = (callArgs: any) => {
+            if (config.validation?.args) {
+              const { errors } = config.validation.args(callArgs)
+
+              if (errors && 'message' in errors[0]) {
+                expect(errors[0].message).toEqual('must be object')
+                done()
+                return
+              }
+            }
+
+            handler(callArgs, {})
+          }
+        },
+      })
+
+      Create(
+        'test',
+        {
+          schema: {
+            args: v.object({}),
+          },
+        },
+        async () => {
+          done()
+        },
+      )
+
+      mockHttpCall()
+    }))
+
+  test('Procedures - Create args validation w/ missing args', async () =>
+    new Promise<void>((done) => {
+      let mockHttpCall: any
+
+      const { Create } = Procedures({
+        onCreate: async ({ handler, config, name }) => {
+          mockHttpCall = async (callArgs: any) => {
+            if (config.validation?.args) {
+              const { errors } = config.validation.args(callArgs)
+              expect(errors).toBeDefined()
+              expect(errors?.length).toEqual(2)
+            }
+
+            try {
+              await handler(callArgs, {})
+            } catch (e: any) {
+              expect(e).instanceof(ProcedureValidationError)
+              expect(e.errors.length).toEqual(2)
+              done()
+            }
+          }
+        },
+      })
+
+      Create(
+        'test',
+        {
+          schema: {
+            args: v.object({
+              name: v.string().required(),
+              id: v.number().required(),
+              email: v.string(),
+            }),
+          },
+        },
+        async () => {
+          return
+        },
+      )
+
+      mockHttpCall({})
+    }))
+
+  test('Procedures - Create call provides ctx to handler', () =>
+    new Promise<void>((done) => {
+      let mockHttpCall: any
+
+      const { Create } = Procedures<{
+        testCtx: string
+      }>({
+        onCreate: ({ handler }) => {
+          mockHttpCall = () => handler({ testCtx: 'testCtx' })
+        },
+      })
+
+      Create('test', {}, async (ctx, args) => {
+        expect(ctx.testCtx).toEqual('testCtx')
+        done()
+      })
+
+      mockHttpCall()
+    }))
+
+  test('Procedures - Create call provides ctx, local ctx & hook context to handler', () =>
+    new Promise<void>((done) => {
+      let mockHttpCall: any
+
+      const { Create } = Procedures<{
+        testCtx: string
+      }>({
+        onCreate: ({ handler }) => {
+          mockHttpCall = () => handler({ testCtx: 'testCtx' })
+        },
+      })
+
+      Create(
+        'test',
+        {
+          hook: async () => ({ localCtx: 'localCtx' }),
+        },
+        async (ctx, args) => {
+          expect(ctx.testCtx).toEqual('testCtx')
+          expect(ctx.localCtx).toEqual('localCtx')
+          expect(ctx.error(400, 'error')).toBeInstanceOf(ProcedureError)
+          done()
+        },
+      )
+
+      mockHttpCall()
+    }))
+
+  test('Procedure hook can throw local ctx error and is caught', async () => {
+    const { Create } = Procedures()
+
+    const { TestProcedureHookError } = Create(
+      'TestProcedureHookError',
+      {
+        hook: async (ctx) => {
+          throw ctx.error(400, 'Local context error')
+        },
+      },
+      async () => null,
+    )
+
+    try {
+      await TestProcedureHookError({}, {})
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(ProcedureError)
+      expect(e.code).toEqual(400)
+      expect(e.message).toEqual('Local context error')
+      expect(e.procedureName).toEqual('TestProcedureHookError')
+    }
+  })
+
+  test('Procedure hook can throw any error and is caught as ProcedureHookError', async () => {
+    const { Create } = Procedures()
+
+    const { TestProcedureHookError } = Create(
+      'TestProcedureHookError',
+      {
+        hook: async (ctx) => {
+          throw new Error('Local context error')
+        },
+      },
+      async () => null,
+    )
+
+    try {
+      await TestProcedureHookError({}, {})
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(ProcedureHookError)
+      expect(e.code).toEqual(ProcedureCodes.PRECONDITION_FAILED)
+      expect(e.message).toContain('Local context error')
+      expect(e.procedureName).toEqual('TestProcedureHookError')
+    }
+  })
+
+  test('Procedure handler can throw local ctx error and is caught', async () => {
+    const { Create } = Procedures()
+
+    const { TestProcedureHandlerError } = Create(
+      'TestProcedureHandlerError',
+      {},
+      async (ctx) => {
+        throw ctx.error(400, 'Local context error')
+      },
+    )
+
+    try {
+      await TestProcedureHandlerError({}, {})
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(ProcedureError)
+      expect(e.code).toEqual(400)
+      expect(e.message).toEqual('Local context error')
+      expect(e.procedureName).toEqual('TestProcedureHandlerError')
+    }
+  })
+
+  test('Procedure handler can call other Procedures and local ctx is not overwritten', async () => {
+    const { Create } = Procedures()
+
+    const { TestProcedure1 } = Create(
+      'TestProcedure1',
+      {
+        hook: async (ctx) => {
+          return { test: 'test1' }
+        },
+
+        schema: {
+          args: v.any(),
+        },
+      },
+      async (ctx, args) => {
+        if (args) return { local: ctx.test }
+
+        // this will throw an error when no args are provided
+        throw ctx.error(400, 'Local context error', { local: ctx.test })
+      },
+    )
+
+    const { TestProcedure2 } = Create(
+      'TestProcedure2',
+      {
+        hook: async (ctx) => {
+          return { test: 'test2' }
+        },
+
+        schema: {
+          args: v.any(),
+        },
+      },
+      async (ctx, args) => {
+        return await TestProcedure1(ctx, args)
+      },
+    )
+
+    try {
+      await TestProcedure2({}, undefined)
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(ProcedureError)
+      expect(e.code).toEqual(400)
+      expect(e.message).toEqual('Local context error')
+      expect(e.procedureName).toEqual('TestProcedure1')
+      expect(e.meta.local).toEqual('test1')
+    }
+
+    const result = await TestProcedure2({}, { any: 'any' })
+    expect(result).toEqual({ local: 'test1' })
+  })
+
+  test('Procedures - getRegisteredProcedures', () => {
+    const { Create, getProcedures } = Procedures({
+      onCreate: () => {
+        return undefined
+      },
+    })
+
+    Create(
+      'test-docs',
+      {
+        schema: {
+          args: v.object({ name: v.string().required() }),
+          data: v.string(),
+        },
+      },
+      async () => {
+        return 'test-docs'
+      },
+    )
+
+    expect(getProcedures().get('test-docs')).toBeDefined()
+    expect(getProcedures().get('test-docs')?.config?.schema).toEqual({
+      args: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+          },
+        },
+        required: ['name'],
+      },
+      data: {
+        type: 'string',
+      },
+    })
+  })
+
+  test('Procedures - context() throws', async () => {
+    interface CustomContext {
+      authToken: string
+    }
+
+    const { Create } = Procedures<CustomContext>()
+
+    function validateAuthToken(token: string) {
+      return token === 'valid-token'
+    }
+
+    function getUserFromToken(token: string) {
+      return { id: 'user-id' }
+    }
+
+    const { CheckIsAuthenticated } = Create(
+      'CheckIsAuthenticated',
+      {
+        hook: async (ctx) => {
+          if (validateAuthToken(ctx.authToken)) {
+            const user = await getUserFromToken(ctx.authToken)
+
+            return { user }
+          }
+
+          throw ctx.error(ProcedureCodes.UNAUTHORIZED, 'Invalid auth token')
+        },
+
+        schema: {
+          data: v.string(),
+        },
+      },
+      async () => {
+        return 'User authentication is valid'
+      },
+    )
+
+    await expect(
+      CheckIsAuthenticated({ authToken: 'valid-token' }, {}),
+    ).resolves.toEqual('User authentication is valid')
+    await expect(
+      CheckIsAuthenticated({ authToken: 'not-valid-token' }, {}),
+    ).rejects.toThrowError(ProcedureError)
+  })
+})

package/src/index.ts

@@ -0,0 +1,200 @@
+import {
+  ProcedureHookError,
+  ProcedureError,
+  ProcedureValidationError,
+} from './errors.js'
+import { ProcedureCodes } from './procedure-codes.js'
+import { computeSchema } from './schema/compute-schema.js'
+import { TJSONSchema, TSchemaLib } from './schema/types.js'
+
+export type TNoContextProvided = unknown
+
+export type TLocalContext = {
+  error: (
+    code: ProcedureCodes & number,
+    message: string,
+    meta?: object,
+  ) => ProcedureError
+}
+
+export type TProcedureRegistration = {
+  name: string
+  config: {
+    description?: string
+    hook?: (ctx: any, args?: any) => any
+    schema?: {
+      args?: TJSONSchema
+      data?: TJSONSchema
+    }
+    validation?: {
+      args?: (args: any) => { errors?: any[] }
+    }
+  }
+
+  handler: (ctx: any, args?: any) => Promise<any>
+}
+
+export function Procedures<TContext = TNoContextProvided>(
+  /**
+   * Optionally provided builder to register Procedures
+   */
+  builder?: {
+    onCreate?: (config: TProcedureRegistration) => void
+  },
+) {
+  const procedures: Map<
+    string,
+    {
+      name: string
+      config: TProcedureRegistration['config']
+      handler: (ctx: TContext, args: any) => Promise<any>
+    }
+  > = new Map()
+
+  function Create<TName extends string, TArgs, TData, TLocalHook>(
+    name: TName,
+    config: {
+      description?: string
+      hook?: (
+        ctx: TContext & TLocalContext,
+        args: TSchemaLib<TArgs>,
+      ) => Promise<TLocalHook>
+      schema?: {
+        args?: TArgs
+        data?: TData
+      }
+    },
+    handler: (
+      ctx: TContext & TLocalContext & TLocalHook,
+      args: TSchemaLib<TArgs>,
+    ) => Promise<TSchemaLib<TData>>,
+  ): {
+    [K in TName | `${TName}_Info`]: K extends TName
+      ? (ctx: TContext, args: TSchemaLib<TArgs>) => Promise<TSchemaLib<TData>>
+      : {
+          description?: string
+          schema: {
+            args?: TSchemaLib<TArgs> extends unknown ? undefined : TJSONSchema
+            data?: TSchemaLib<TData> extends unknown ? undefined : TJSONSchema
+          }
+        }
+  } {
+    const { jsonSchema, validations } = computeSchema(name, config.schema)
+
+    const registeredProcedure = {
+      name,
+      config: {
+        ctx: config.hook,
+        description: config.description,
+        schema: jsonSchema,
+        validation: {
+          args: validations.args,
+        },
+      },
+
+      handler: async (ctx: TContext, args: TSchemaLib<TArgs>) => {
+        try {
+          if (validations?.args) {
+            const { errors } = validations.args(args)
+
+            if (errors) {
+              throw new ProcedureValidationError(
+                name,
+                `Validation error for ${name} - ${errors.map((e) => e.message).join(', ')}`,
+                errors,
+              )
+            }
+          }
+
+          const localCtx: TLocalContext = {
+            error: (
+              code: ProcedureCodes & number,
+              message: string,
+              meta?: object,
+            ) => {
+              return new ProcedureError(name, code, message, meta)
+            },
+          }
+
+          let computedLocalHook: TLocalHook = {} as TLocalHook
+
+          if (config.hook) {
+            try {
+              computedLocalHook = (await config.hook(
+                { ...localCtx, ...ctx },
+                args,
+              )) as TLocalHook
+            } catch (error: any) {
+              if (error instanceof ProcedureError) {
+                throw error
+              }
+
+              const err = new ProcedureHookError(
+                name,
+                `Error in hook for ${name} - ${error?.message}`,
+              )
+              err.stack = error.stack
+              throw err
+            }
+          }
+
+          return handler(
+            {
+              ...ctx,
+              ...localCtx,
+              ...computedLocalHook,
+            } as TContext & TLocalContext & TLocalHook,
+            args,
+          )
+        } catch (error: any) {
+          if (error instanceof ProcedureHookError) {
+            throw error
+          } else if (error instanceof ProcedureError) {
+            throw error
+          } else {
+            const err = new ProcedureError(
+              name,
+              ProcedureCodes.HANDLER_ERROR,
+              `Error in handler for ${name} - ${error?.message}`,
+            )
+            err.stack = error.stack
+            throw err
+          }
+        }
+      },
+    }
+
+    procedures.set(name, registeredProcedure)
+
+    if (builder?.onCreate) {
+      builder.onCreate(registeredProcedure)
+    }
+
+    // return for testing so that the rpc can be called/tested individually or internally
+    return {
+      [name]: registeredProcedure.handler,
+      [`${name}_Info`]: {
+        description: config.description,
+        schema: jsonSchema,
+      },
+    } as {
+      [K in TName | `${TName}_Info`]: K extends TName
+        ? typeof registeredProcedure.handler
+        : {
+            description?: string
+            schema: {
+              args?: TSchemaLib<TArgs> extends unknown ? undefined : TJSONSchema
+              data?: TSchemaLib<TData> extends unknown ? undefined : TJSONSchema
+            }
+          }
+    }
+  }
+
+  return {
+    getProcedures: () => {
+      return procedures
+    },
+
+    Create,
+  }
+}

package/src/procedure-codes.ts

@@ -0,0 +1,26 @@
+/**
+ * A list of common codes borrowed from HTTP status codes.
+ */
+export enum ProcedureCodes {
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  TIMEOUT = 408,
+  CONFLICT = 409,
+  PRECONDITION_FAILED = 412,
+  VALIDATION_ERROR = 422,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_ERROR = 500,
+  HANDLER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  SERVICE_UNAVAILABLE = 503,
+}

package/src/schema/compute-schema.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from 'vitest'
+import { Type } from '@sinclair/typebox'
+import { v } from 'suretype'
+import { computeSchema } from './compute-schema.js'
+import { ProcedureRegistrationError } from '../errors.js'
+
+describe('computeSchema', () => {
+  it('should return empty schema and validations when no schema provided', () => {
+    const result = computeSchema('test-procedure')
+
+    expect(result).toEqual({
+      jsonSchema: { args: undefined, data: undefined },
+      validations: {}
+    })
+  })
+
+  describe('with Typebox schema', () => {
+    it('should correctly process args schema', () => {
+      const schema = {
+        args: Type.Object({
+          name: Type.String(),
+          age: Type.Number()
+        })
+      }
+
+      const result = computeSchema('test-procedure', schema)
+
+      expect(result.jsonSchema.args).toBeDefined()
+      expect(result.validations.args).toBeDefined()
+
+      // Test validation function
+      const validInput = { name: 'John', age: 30 }
+      expect(result.validations.args?.(validInput).errors).toBeUndefined()
+
+      // Test invalid input
+      const invalidInput = { name: 123, age: 'invalid' }
+      expect(result.validations.args?.(invalidInput).errors).toBeDefined()
+    })
+
+    it('should correctly process data schema', () => {
+      const schema = {
+        data: Type.Object({
+          result: Type.Boolean()
+        })
+      }
+
+      const result = computeSchema('test-procedure', schema)
+
+      expect(result.jsonSchema.data).toBeDefined()
+      expect(result.validations.args).toBeUndefined()
+    })
+  })
+
+  describe('with Suretype schema', () => {
+    it('should correctly process args schema', () => {
+      const schema = {
+        args: v.object({
+          name: v.string(),
+          age: v.number()
+        })
+      }
+
+      const result = computeSchema('test-procedure', schema)
+
+      expect(result.jsonSchema.args).toBeDefined()
+      expect(result.validations.args).toBeDefined()
+
+      // Test validation function
+      const validInput = { name: 'John', age: 30 }
+      expect(result.validations.args?.(validInput).errors).toBeUndefined()
+
+      // Test invalid input
+      const invalidInput = { name: 123, age: 'invalid' }
+      expect(result.validations.args?.(invalidInput).errors).toBeDefined()
+    })
+  })
+
+  describe('error handling', () => {
+    it('should throw ProcedureRegistrationError for invalid schema', () => {
+      const invalidSchema = {
+        args: {
+          type: 'invalid-schema-type'
+        }
+      }
+
+      expect(() => computeSchema('test-procedure', invalidSchema))
+        .toThrow(ProcedureRegistrationError)
+    })
+
+    it('should include procedure name in error message', () => {
+      const invalidSchema = {
+        args: {
+          type: 'invalid-schema-type'
+        }
+      }
+
+      try {
+        computeSchema('test-procedure', invalidSchema)
+      } catch (error: any) {
+        expect(error instanceof ProcedureRegistrationError).toBe(true)
+        expect(error.message).toContain('test-procedure')
+      }
+    })
+  })
+
+  describe('combined schemas', () => {
+    it('should handle both args and data schemas', () => {
+      const schema = {
+        args: Type.Object({
+          input: Type.String()
+        }),
+        data: Type.Object({
+          output: Type.Boolean()
+        })
+      }
+
+      const result = computeSchema('test-procedure', schema)
+
+      expect(result.jsonSchema.args).toBeDefined()
+      expect(result.jsonSchema.data).toBeDefined()
+      expect(result.validations.args).toBeDefined()
+
+      // Test args validation
+      const validInput = { input: 'test' }
+      expect(result.validations.args?.(validInput).errors).toBeUndefined()
+    })
+  })
+})

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<TArgsSchemaType, TDataSchemaType>(
+  name: string,
+  schema?: {
+    args?: TArgsSchemaType
+    data?: TDataSchemaType
+  },
+): {
+  jsonSchema: {
+    args?: TJSONSchema
+    data?: TJSONSchema
+  }
+  validations: {
+    args?: (args?: any) => { errors?: TSchemaValidationError[] }
+  }
+} {
+  const jsonSchema: { args?: TJSONSchema; data?: TJSONSchema } = {
+    args: undefined,
+    data: undefined,
+  }
+
+  const validations: {
+    args?: (args?: any) => { errors?: TSchemaValidationError[] }
+  } = {}
+
+  if (schema) {
+    const {
+      jsonSchema: { args, data },
+      validation,
+    } = schemaParser(schema, (errors) => {
+      throw new ProcedureRegistrationError(
+        name,
+        `Error parsing schema for ${name} - ${Object.entries(errors)
+          .map(([key, error]) => `${key}: ${error}`)
+          .join(', ')}`,
+      )
+    })
+
+    jsonSchema.args = args
+    jsonSchema.data = data
+    validations.args = validation.args
+  }
+
+  return { jsonSchema, validations }
+}

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

@@ -0,0 +1,25 @@
+import { describe, expect, test } from 'vitest'
+import { Type } from '@sinclair/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 '@sinclair/typebox'
+
+describe('schemaParser', () => {
+  test('it parses args to json-schema', async () => {
+    let done: () => void = () => void 0
+    const promise = new Promise<void>((r) => {
+      done = r
+    })
+
+    const args = v.object({
+      name: v.string(),
+      age: v.number(),
+    })
+
+    const result = schemaParser(
+      {
+        args: args,
+      },
+      (errors) => {
+        throw new Error(JSON.stringify(errors))
+      },
+    )
+
+    expect(result.jsonSchema.args).toEqual(
+      extractSingleJsonSchema(args)?.schema,
+    )
+
+    done()
+
+    await promise
+    await promise
+  })
+
+  test('it parses args and generates a validator function', async () => {
+    let done: () => void = () => void 0
+    const promise = new Promise<void>((r) => {
+      done = r
+    })
+
+    const args = v.object({
+      name: v.string(),
+      age: v.number().required(),
+    })
+
+    const result = schemaParser(
+      {
+        args: args,
+      },
+      (errors) => {
+        throw new Error(JSON.stringify(errors))
+      },
+    )
+
+    expect(
+      result.validation.args?.({
+        name: 'John',
+        age: 30,
+      })?.errors,
+    ).toBeUndefined()
+
+    expect(
+      result.validation.args?.({
+        name: { name: '' },
+        age: 'poop',
+      })?.errors,
+    ).toBeDefined()
+
+    expect(
+      result.validation.args?.({
+        name: { name: '' },
+        age: 'poop',
+      })?.errors?.length,
+    ).toEqual(2)
+
+    done()
+
+    await promise
+  })
+
+  test('it parses data to json-schema', async () => {
+    let done: () => void = () => void 0
+    const promise = new Promise<void>((r) => {
+      done = r
+    })
+
+    const data = v.object({
+      name: v.string(),
+      age: v.number(),
+    })
+
+    const result = schemaParser(
+      {
+        data: data,
+      },
+      (errors) => {
+        throw new Error(JSON.stringify(errors))
+      },
+    )
+
+    expect(result.jsonSchema.data).toEqual(
+      extractSingleJsonSchema(data)?.schema,
+    )
+
+    done()
+
+    await promise
+  })
+
+  test('it throws a meaningful error to the dev', async () => {
+    schemaParser(
+      // invalid args schema
+      { args: { test: Type.String() } },
+      (errors) => {
+        expect(errors.args).toMatch(/Error extracting json schema schema.args/)
+      },
+    )
+
+    schemaParser(
+      // invalid data schema
+      { data: 'string value' },
+      (errors) => {
+        expect(errors.data).toMatch(/Error extracting json schema schema.data/)
+      },
+    )
+  })
+
+  test('it parses multiple schemas correct', async () => {
+    const schema = schemaParser(
+      {
+        args: Type.Object({ a: Type.String() }),
+        data: Type.Object({ b: Type.Null() }),
+      },
+      (error) => {
+        throw new Error(JSON.stringify(error))
+      },
+    )
+
+    const schema2= schemaParser(
+      {
+        args: Type.Object({ c: Type.String() }),
+        data: Type.Object({ d: Type.Number() }),
+      },
+      (error) => {
+        throw new Error(JSON.stringify(error))
+      },
+    )
+
+    expect(schema.validation.args?.({}).errors?.[0]?.message).toMatch(/must have required property 'a'/)
+    expect(schema2.validation.args?.({ c: 'test' })
+    ).toMatchObject({})
+    expect(schema.validation.args?.({}).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: { args?: TJSONSchema; data?: TJSONSchema }
+  validation: { args?: (args: 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: { args?: unknown; data?: unknown },
+  onParseError: (errors: { args?: string; data?: string }) => void,
+): TSchemaParsed {
+  const jsonSchema: TSchemaParsed['jsonSchema'] = {}
+  const validation: TSchemaParsed['validation'] = {}
+
+  if (schema.args) {
+    try {
+      const extracted = extractJsonSchema(schema.args as TJSONSchema)
+
+      if (extracted) {
+        jsonSchema.args = extracted
+      }
+    } catch (e: any) {
+      onParseError({
+        args: `Error extracting json schema schema.args - ${e.message}`,
+      })
+    }
+
+    if (!jsonSchema.args) {
+      onParseError({
+        args: `Error extracting json schema schema.args - schema.args might be empty or it is not a valid suretype or typebox type`,
+      })
+    } else {
+      let argsValidator: AJV.ValidateFunction
+
+      try {
+        argsValidator = ajv.compile(jsonSchema.args as TJSONSchema)
+      } catch (e: any) {
+        onParseError({
+          args: `Error compiling schema.args for validator - ${e.message}`,
+        })
+      }
+
+      validation.args = (args: any) => {
+        const valid = argsValidator(args)
+
+        if (!valid) {
+          const errors = argsValidator.errors
+
+          return {
+            errors: errors?.length ? errors : undefined,
+          }
+        }
+
+        return {}
+      }
+    }
+  }
+
+  if (schema.data) {
+    try {
+      const extracted = extractJsonSchema(schema.data as TJSONSchema)
+
+      jsonSchema.data = extracted
+    } catch (e: any) {
+      onParseError({
+        data: `Error extracting json schema schema.data - ${e.message}`,
+      })
+    }
+
+    if (!jsonSchema.data) {
+      onParseError({
+        data: `Error extracting json schema schema.data - schema.data 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 '@sinclair/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,23 @@
+import { Static } from '@sinclair/typebox'
+import { CoreValidator } from 'suretype'
+
+export type IsTypeboxSchema<TSchema> =
+  TSchema extends {static: unknown, params: unknown} ? true
+    : false;
+
+export function isTypeboxSchema(
+  schema: any,
+): schema is Static<any> {
+  return 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,12 @@
+import { CoreValidator, TypeOf } from 'suretype'
+import { Static, TSchema } from '@sinclair/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>