confluent-schema-registry 3.3.6 → 3.6.2

package/CHANGELOG.md

@@ -9,7 +9,48 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 
--field for error validation , and the issue of failing
+- Support [schema references](https://docs.confluent.io/platform/current/schema-registry/serdes-develop/index.html#schema-references) for Avro, Protocol Buffer, and JSON schema [#197](https://github.com/kafkajs/confluent-schema-registry/pull/197)
+
+### Fixed
+
+- Fix Apicurio compatibility with register function [#201](https://github.com/kafkajs/confluent-schema-registry/pull/201)
+
+## [3.2.1] - 2022-01-28
+
+### Fixed
+
+- Don't swallow error message from client-side errors from registry requests [#176](https://github.com/kafkajs/confluent-schema-registry/pull/176)
+
+## [3.2.0] - 2021-11-22
+
+### Added
+
+- Add reader schema option when decoding Avro messages [#166](https://github.com/kafkajs/confluent-schema-registry/pull/166)
+
+## [3.1.1] - 2021-11-03
+
+### Fixed
+
+- Support backwards incompatible changes in Ajv 8 when passing in Ajv instance in JSON Schema options [#163](https://github.com/kafkajs/confluent-schema-registry/pull/163)
+
+## [3.1.0] - 2021-11-03
+
+### Added
+
+- Allow passing in Ajv instance in JSON Schema options [#133](https://github.com/kafkajs/confluent-schema-registry/pull/133)
+
+### Fixed
+
+- Fix backwards compatibility with older Schema Registry versions [#158](https://github.com/kafkajs/confluent-schema-registry/pull/158)
+
+### Fixed
+
+- Fix gateway config for when setting HTTP agent [#127](https://github.com/kafkajs/confluent-schema-registry/pull/127)
+
+## [3.0.1] - 2021-06-11
+### Fixed
+
+- Fix gateway config for when setting HTTP agent [#127](https://github.com/kafkajs/confluent-schema-registry/pull/127)
 
 ## [3.0.0] - 2021-05-20
 

package/bin/avdlToAVSC.sh

@@ -6,4 +6,4 @@ if [ -z "${avdl_path}" ]; then
   exit;
 fi
 
-docker run --rm -v ${PWD}:/share coderfi/avro-tools:1.7.7 idl2schemata ${avdl_path} tmp && cat tmp/${avsc_name}.avsc
+docker run --rm -v "$(pwd)":/avro kpnnl/avro-tools:1.12.0 idl2schemata ${avdl_path} tmp && cat tmp/${avsc_name}.avsc

package/dockest-error.json

@@ -1,11 +1,7 @@
 {
   "errorPayload": {
-    "trap": "unhandledRejection",
-    "reason": {
-      "payload": {},
-      "name": "DockestError"
-    },
-    "promise": {}
+    "trap": "SIGINT",
+    "signal": "SIGINT"
   },
-  "timestamp": "2024-09-03T14:42:35.241Z"
+  "timestamp": "2024-12-18T22:39:59.117Z"
 }

package/jest.setup.ts

@@ -1,8 +1,12 @@
 import { MAGIC_BYTE } from './src/wireEncoder'
 import decode from './src/wireDecoder'
+import { MatcherFunction } from 'expect'
 
-const toMatchConfluentEncodedPayload = context => (received, { payload: expectedPayload }) => {
-  const { printExpected, printReceived, printWithType } = context.utils
+const toMatchConfluentEncodedPayload: MatcherFunction<[{ payload: Buffer }]> = function(
+  received,
+  { payload: expectedPayload },
+) {
+  const { printExpected, printReceived, printWithType } = this.utils
 
   if (!Buffer.isBuffer(expectedPayload)) {
     const error = [
@@ -13,16 +17,17 @@ const toMatchConfluentEncodedPayload = context => (received, { payload: expected
     throw new Error(error)
   }
 
-  const { magicByte, payload } = decode(received)
+  const { magicByte, payload } = decode(received as Buffer)
   const expectedMessage = decode(expectedPayload)
 
   if (!Buffer.isBuffer(received)) {
     return {
       pass: false,
-      message: () => [
-        'Received value must be a Buffer',
-        printWithType('Received', received, printReceived),
-      ],
+      message: () =>
+        [
+          'Received value must be a Buffer',
+          printWithType('Received', received, printReceived),
+        ].join('\n'),
     }
   }
 
@@ -40,7 +45,7 @@ const toMatchConfluentEncodedPayload = context => (received, { payload: expected
   }
 
   return {
-    pass: context.equals(payload, expectedMessage.payload),
+    pass: this.equals(payload, expectedMessage.payload),
     message: () =>
       [
         'expected payload',
@@ -52,9 +57,14 @@ const toMatchConfluentEncodedPayload = context => (received, { payload: expected
 }
 
 expect.extend({
-  toMatchConfluentEncodedPayload(...args) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-    // @ts-ignore
-    return toMatchConfluentEncodedPayload(this)(...args)
-  },
+  toMatchConfluentEncodedPayload,
 })
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace jest {
+    interface Matchers<R, T = {}> {
+      toMatchConfluentEncodedPayload(args: { registryId: number; payload: Buffer }): R
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluent-schema-registry",
-  "version": "3.3.6",
+  "version": "3.6.2",
   "main": "dist/index.js",
   "description": "ConfluentSchemaRegistry is a library that makes it easier to interact with the Confluent schema registry, it provides convenient methods to encode, decode and register new schemas using the Apache Avro serialization format.",
   "keywords": [
@@ -17,40 +17,34 @@
     "build:watch": "rm -rf ./dist && tsc --watch",
     "test:unit:watch": "yarn test:unit --watch",
     "test:unit": "jest",
-    "test": "ts-node ./dockest.ts",
-    "test:debug": "ts-node ./dockest.ts debug",
+    "test": "docker compose up -d --wait schemaRegistry && jest",
     "lint": "eslint './src/**/*.ts'",
+    "check:types": "tsc --noEmit",
     "format": "yarn lint --fix"
   },
   "dependencies": {
     "ajv": "^7.1.0",
     "avsc": ">= 5.4.13 < 6",
-    "mappersmith": ">= 2.30.1 < 3",
-    "protobufjs": "^6.11.4"
+    "mappersmith": ">= 2.44.0 < 3",
+    "protobufjs": ">= 6.11.4 < 8"
   },
   "devDependencies": {
-    "@types/execa": "^2.0.0",
-    "@types/fs-extra": "^8.0.0",
-    "@types/jest": "^25.2.1",
-    "@types/node": "^12.7.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^18.19.70",
     "@types/prettier": "^1.18.2",
-    "@types/uuid": "^3.4.5",
     "@typescript-eslint/eslint-plugin": "^2.1.0",
     "@typescript-eslint/parser": "^2.1.0",
     "@typescript-eslint/typescript-estree": "^2.1.0",
     "ajv8": "npm:ajv@^8.6.3",
-    "dockest": "^2.1.0",
     "eslint": "^6.3.0",
     "eslint-config-prettier": "^6.1.0",
     "eslint-plugin-no-only-tests": "^2.3.1",
     "eslint-plugin-prettier": "^3.1.0",
-    "execa": "^2.0.4",
-    "fs-extra": "^8.1.0",
-    "jest": "^25.2.7",
+    "jest": "^29.7.0",
     "prettier": "^1.18.2",
-    "ts-jest": "^24.0.2",
+    "ts-jest": "^29.2.5",
     "ts-node": "^8.3.0",
-    "typescript": "^3.6.2",
-    "uuid": "^3.3.3"
+    "typescript": "^5.7.3",
+    "uuid": "^11.0.5"
   }
 }

package/src/@types.ts

@@ -23,10 +23,12 @@ export type AvroOptions = Partial<ForSchemaOptions> & {
 }
 
 export type JsonOptions = ConstructorParameters<typeof Ajv>[0] & {
-  ajvInstance?: {
-    addSchema: Ajv['addSchema']
-    compile: (schema: any) => ValidateFunction
-  }
+  ajvInstance?:
+    | {
+        addSchema: Ajv['addSchema']
+        compile: (schema: any) => ValidateFunction
+      }
+    | Ajv
   referencedSchemas?: JsonConfluentSchema[]
 }
 export type ProtoOptions = { messageName?: string; referencedSchemas?: ProtoConfluentSchema[] }
@@ -94,12 +96,3 @@ export interface SchemaResponse {
 }
 
 export type ConfluentSchema = AvroConfluentSchema | ProtoConfluentSchema | JsonConfluentSchema
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    interface Matchers<R, T = {}> {
-      toMatchConfluentEncodedPayload(args: { registryId: number; payload: Buffer }): R
-    }
-  }
-}

package/src/AvroHelper.ts

@@ -12,7 +12,7 @@ import { ConfluentSchemaRegistryArgumentError } from './errors'
 import avro, { ForSchemaOptions, Schema, Type } from 'avsc'
 import { SchemaResponse, SchemaType } from './@types'
 
-type TypeHook = (schema: Schema, opts: ForSchemaOptions) => Type
+type TypeHook = (schema: Schema, opts: ForSchemaOptions) => Type | undefined
 export default class AvroHelper implements SchemaHelper {
   private getRawAvroSchema(schema: ConfluentSchema): RawAvroSchema {
     return (typeof schema.schema === 'string'
@@ -57,8 +57,7 @@ export default class AvroHelper implements SchemaHelper {
 
   public getSubject(
     schema: AvroConfluentSchema,
-    // @ts-ignore
-    avroSchema: AvroSchema,
+    _avroSchema: AvroSchema,
     separator: string,
   ): ConfluentSubject {
     const rawSchema: RawAvroSchema = this.getRawAvroSchema(schema)

package/src/JsonSchema.ts

@@ -5,6 +5,7 @@ import { ConfluentSchemaRegistryValidationError } from './errors'
 interface BaseAjvValidationError {
   data?: unknown
   schema?: unknown
+  message?: string
 }
 interface OldAjvValidationError extends BaseAjvValidationError {
   dataPath: string
@@ -41,8 +42,15 @@ export default class JsonSchema implements Schema {
   }
 
   private validatePayload(payload: any) {
-    const paths: string[][] = []
-    if (!this.isValid(payload, { errorHook: path => paths.push(path) })) {
+    const paths: any[] = []
+
+    if (
+      !this.isValid(payload, {
+        errorHook: (path, message) => {
+          paths.push({ path, message })
+        },
+      })
+    ) {
       throw new ConfluentSchemaRegistryValidationError('invalid payload', paths)
     }
   }
@@ -57,19 +65,23 @@ export default class JsonSchema implements Schema {
     this.validatePayload(payload)
     return payload
   }
-  public isValid(payload: object, opts?: { errorHook: (path: Array<string>, value: any, type?: any) => void }): boolean {  
-    if (!this.validate(payload)) {  
-      if (opts === null || opts === void 0 ? void 0 : opts.errorHook) {
-        for (const err of (this.validate.errors as any)) {  
-          const path = this.isOldAjvValidationError(err) ? err.dataPath : err.instancePath;  
-          opts.errorHook([err], err.data, err.schema);
-        }  
-      }  
-      return false;  
-    }  
-    return true;  
-  }  
-  
+
+  public isValid(
+    payload: object,
+    opts?: { errorHook: (path: Array<string>, value: any, type?: any) => void },
+  ): boolean {
+    if (!this.validate(payload)) {
+      if (opts?.errorHook) {
+        for (const err of this.validate.errors as AjvValidationError[]) {
+          const path = this.isOldAjvValidationError(err) ? err.dataPath : err.instancePath
+          opts.errorHook([path], err.message ?? err.data, err.schema)
+        }
+        return false
+      }
+    }
+    return true
+  }
+
   private isOldAjvValidationError(error: AjvValidationError): error is OldAjvValidationError {
     return (error as OldAjvValidationError).dataPath != null
   }

package/src/SchemaRegistry.json.spec.ts

@@ -1,6 +1,8 @@
 import SchemaRegistry, { RegisteredSchema } from './SchemaRegistry'
 import API from './api'
 import { JsonConfluentSchema, SchemaType } from './@types'
+import Ajv from 'ajv'
+import { ConfluentSchemaRegistryValidationError } from './errors'
 
 const REGISTRY_HOST = 'http://localhost:8982'
 const schemaRegistryAPIClientArgs = { host: REGISTRY_HOST }
@@ -100,8 +102,13 @@ describe('SchemaRegistry', () => {
   let api
 
   beforeEach(async () => {
+    const options = {
+      [SchemaType.JSON]: {
+        allErrors: true,
+      },
+    }
     api = API(schemaRegistryAPIClientArgs)
-    schemaRegistry = new SchemaRegistry(schemaRegistryArgs)
+    schemaRegistry = new SchemaRegistry(schemaRegistryArgs, options)
   })
 
   describe('when register', () => {
@@ -161,6 +168,16 @@ describe('SchemaRegistry', () => {
 
         expect(resultObj).toEqual(obj)
       })
+
+      it('should return error message', async () => {
+        const obj = { id2a: 'sdfsdfsdf', level2a: 1 }
+        try {
+          await schemaRegistry.encode(registeredSchema.id, obj)
+        } catch (ex) {
+          expect(ex.paths[0].message).toBeDefined()
+          expect(ex.paths[0].message).toEqual('should be number')
+        }
+      })
     })
 
     describe('with multiple reference', () => {

package/src/SchemaRegistry.newApi.spec.ts

@@ -587,7 +587,7 @@ describe('SchemaRegistry - new Api', () => {
           } catch (error) {
             expect(error).toBeInstanceOf(ConfluentSchemaRegistryValidationError)
             expect(error.message).toEqual('invalid payload')
-            expect(error.paths).toEqual([['/fullName']])
+            expect(error.paths[0].path).toEqual(['/fullName'])
           }
         },
       )

package/src/SchemaRegistry.spec.ts

@@ -250,3 +250,18 @@ describe('SchemaRegistry - old AVRO api', () => {
     })
   })
 })
+
+describe('SchemaRegistry - Custom Middleware', () => {
+  const customMiddleware = jest.fn()
+
+  const schemaRegistry = new SchemaRegistry({
+    ...schemaRegistryArgs,
+    middlewares: [customMiddleware],
+  })
+
+  it('should have called the custom middleware', async () => {
+    await schemaRegistry.register(personSchema)
+
+    expect(customMiddleware).toHaveBeenCalled()
+  })
+})

package/src/SchemaRegistry.ts

@@ -3,7 +3,7 @@ import { Response } from 'mappersmith'
 
 import { encode, MAGIC_BYTE } from './wireEncoder'
 import decode from './wireDecoder'
-import { COMPATIBILITY, DEFAULT_SEPERATOR } from './constants'
+import { COMPATIBILITY, DEFAULT_SEPARATOR } from './constants'
 import API, { SchemaRegistryAPIClientArgs, SchemaRegistryAPIClient } from './api'
 import Cache from './cache'
 import {
@@ -46,13 +46,13 @@ interface Opts {
 interface AvroDecodeOptions {
   readerSchema?: RawAvroSchema | AvroSchema | Schema
 }
-interface DecodeOptions {
+export interface DecodeOptions {
   [SchemaType.AVRO]?: AvroDecodeOptions
 }
 
 const DEFAULT_OPTS = {
   compatibility: COMPATIBILITY.BACKWARD,
-  separator: DEFAULT_SEPERATOR,
+  separator: DEFAULT_SEPARATOR,
 }
 export default class SchemaRegistry {
   private api: SchemaRegistryAPIClient
@@ -62,10 +62,10 @@ export default class SchemaRegistry {
   public cache: Cache
 
   constructor(
-    { auth, clientId, host, retry, agent }: SchemaRegistryAPIClientArgs,
+    { auth, clientId, host, retry, agent, middlewares }: SchemaRegistryAPIClientArgs,
     options?: SchemaRegistryAPIClientOptions,
   ) {
-    this.api = API({ auth, clientId, host, retry, agent })
+    this.api = API({ auth, clientId, host, retry, agent, middlewares })
     this.cache = new Cache()
     this.options = options
   }
@@ -138,7 +138,7 @@ export default class SchemaRegistry {
         )
       }
     } catch (error) {
-      if (error.status !== 404) {
+      if (!error || typeof error !== 'object' || !('status' in error) || error.status !== 404) {
         throw error
       } else {
         isFirstTimeRegistration = true
@@ -355,7 +355,7 @@ export default class SchemaRegistry {
 
       return id
     } catch (error) {
-      if (error.status && error.status === 404) {
+      if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
         throw new ConfluentSchemaRegistryError(error)
       }
 
@@ -370,18 +370,17 @@ export default class SchemaRegistry {
     return id
   }
 
-  private getSchemaOriginRequest(registryId: number) {
+  private async getSchemaOriginRequest(registryId: number): Promise<Response> {
     // ensure that cache-misses result in a single origin request
-    if (this.cacheMissRequests[registryId]) {
-      return this.cacheMissRequests[registryId]
-    } else {
-      const request = this.api.Schema.find({ id: registryId }).finally(() => {
-        delete this.cacheMissRequests[registryId]
-      })
+    const req = this.cacheMissRequests[registryId]
+    if (req) return req
 
-      this.cacheMissRequests[registryId] = request
+    const request = this.api.Schema.find({ id: registryId }).finally(() => {
+      delete this.cacheMissRequests[registryId]
+    })
 
-      return request
-    }
+    this.cacheMissRequests[registryId] = request
+
+    return request
   }
 }

package/src/api/index.spec.ts

@@ -1,7 +1,27 @@
+import { Middleware } from 'mappersmith'
 import API from '.'
 import { mockClient, install, uninstall } from 'mappersmith/test'
 
-const client = API({ clientId: 'test-client', host: 'http://example.com' })
+const customMiddleware: Middleware = jest.fn(() => {
+  return {
+    async request(request) {
+      return request.enhance({
+        headers: {
+          Authorization: 'Bearer Random',
+        },
+      })
+    },
+    async response(next) {
+      return next()
+    },
+  }
+})
+
+const client = API({
+  clientId: 'test-client',
+  host: 'http://example.com',
+  middlewares: [customMiddleware],
+})
 const mock = mockClient<typeof client>(client)
   .resource('Schema')
   .method('find')
@@ -14,10 +34,12 @@ describe('API Client', () => {
 
   afterEach(() => uninstall())
 
-  it('should include a user agent header', async () => {
+  it('should include a user agent header and call custom middleware', async () => {
     const response = await client.Schema.find({ id: 'abc' })
 
     expect(mock.callsCount()).toBe(1)
     expect(response.request().header('User-Agent')).not.toBeUndefined()
+    expect(response.request().header('Authorization')).toBe('Bearer Random')
+    expect(customMiddleware).toHaveBeenCalled()
   })
 })

package/src/api/index.ts

@@ -1,5 +1,11 @@
 import { Agent } from 'http'
-import forge, { Authorization, Client, Options, GatewayConfiguration } from 'mappersmith'
+import forge, {
+  Authorization,
+  Client,
+  GatewayConfiguration,
+  Middleware,
+  ManifestOptions,
+} from 'mappersmith'
 import RetryMiddleware, { RetryMiddlewareOptions } from 'mappersmith/middleware/retry/v2'
 import BasicAuthMiddleware from 'mappersmith/middleware/basic-auth'
 
@@ -23,6 +29,7 @@ export interface SchemaRegistryAPIClientArgs {
   retry?: Partial<RetryMiddlewareOptions>
   /** HTTP Agent that will be passed to underlying API calls */
   agent?: Agent
+  middlewares?: Middleware[]
 }
 
 // TODO: Improve typings
@@ -48,10 +55,11 @@ export default ({
   host,
   retry = {},
   agent,
+  middlewares = [],
 }: SchemaRegistryAPIClientArgs): SchemaRegistryAPIClient => {
   const clientId = userClientId || DEFAULT_API_CLIENT_ID
   // FIXME: ResourcesType typings is not exposed by mappersmith
-  const manifest: Options<any> = {
+  const manifest: ManifestOptions<any> = {
     clientId,
     ignoreGlobalMiddleware: true,
     host,
@@ -61,6 +69,7 @@ export default ({
       RetryMiddleware(Object.assign(DEFAULT_RETRY, retry)),
       errorMiddleware,
       ...(auth ? [BasicAuthMiddleware(auth)] : []),
+      ...middlewares,
     ],
     resources: {
       Schema: {

package/src/api/middleware/errorMiddleware.ts

@@ -30,7 +30,7 @@ const errorMiddleware: Middleware = ({ clientId }) => ({
     new Promise((resolve, reject) =>
       next()
         .then(resolve)
-        .catch((response: Response) => reject(new ResponseError(clientId, response))),
+        .catch((response: Response) => reject(new ResponseError(clientId ?? '', response))),
     ),
 })
 

package/src/constants.ts

@@ -8,6 +8,6 @@ export enum COMPATIBILITY {
   FULL_TRANSITIVE = 'FULL_TRANSITIVE',
 }
 
-export const DEFAULT_SEPERATOR = '.'
+export const DEFAULT_SEPARATOR = '.'
 
 export const DEFAULT_API_CLIENT_ID = 'Confluent_Schema_Registry'

package/src/index.ts

@@ -1,4 +1,5 @@
-export { default as SchemaRegistry } from './SchemaRegistry'
+import { default as SchemaRegistry, DecodeOptions } from './SchemaRegistry'
+export { SchemaRegistry, DecodeOptions }
 export * from './utils'
 export { SchemaType } from './@types'
 export { COMPATIBILITY } from './constants'

package/src/schemaTypeResolver.ts

@@ -96,6 +96,7 @@ export const schemaFromConfluentSchema = (
 
     return schema
   } catch (err) {
-    throw new ConfluentSchemaRegistryArgumentError(err.message)
+    if (err instanceof Error) throw new ConfluentSchemaRegistryArgumentError(err.message)
+    throw err
   }
 }

package/src/utils/avdlToAVSC.spec.ts

@@ -1,7 +1,7 @@
 import path from 'path'
-import fs from 'fs-extra'
-import execa from 'execa'
 import avro from 'avsc'
+import { exec } from 'child_process'
+import fs from 'node:fs'
 
 import SchemaRegistry from '../SchemaRegistry'
 import { avdlToAVSCAsync } from './avdlToAVSC'
@@ -9,13 +9,26 @@ import { avdlToAVSCAsync } from './avdlToAVSC'
 const registry = new SchemaRegistry({ host: 'http://localhost:8982' })
 const absolutePath = (...paths: string[]) => path.join(__dirname, '../..', ...paths)
 
+const promisifiedExec = async (command: string): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout) => {
+      if (error) {
+        return reject(error)
+      }
+
+      return resolve(stdout)
+    })
+  })
+}
+
 const compareWithJavaImplementation = (avdlPath: string, name: string) => async () => {
   const absolutePathToAvdlToAVSC = absolutePath('./bin/avdlToAVSC.sh')
-  const execaArgs = [`./fixtures/avdl/${avdlPath}`, name]
 
   let expectedAVSC
   try {
-    const { stdout: result } = await execa(absolutePathToAvdlToAVSC, execaArgs)
+    const result = await promisifiedExec(
+      `${absolutePathToAvdlToAVSC} ./fixtures/avdl/${avdlPath} ${name}`,
+    )
     expectedAVSC = JSON.parse(result)
   } catch (error) {
     console.error(`Error when running ${absolutePathToAvdlToAVSC}`, error) // eslint-disable-line no-console
@@ -31,7 +44,17 @@ const compareWithJavaImplementation = (avdlPath: string, name: string) => async
 
 beforeAll(async () => {
   jest.setTimeout(10000)
-  await fs.emptyDir(absolutePath('./tmp'))
+
+  // deletes all the files from tmp dir
+  const tmpDirectory = absolutePath('./tmp')
+  try {
+    fs.statSync(tmpDirectory)
+  } catch (e) {
+    fs.mkdirSync(tmpDirectory)
+  }
+  for (const file of fs.readdirSync(tmpDirectory)) {
+    fs.unlinkSync(path.join(tmpDirectory, file))
+  }
 })
 
 test('simple protocol', compareWithJavaImplementation('simple.avdl', 'Simple'))

package/src/utils/avdlToAVSC.ts

@@ -21,7 +21,7 @@ interface Field {
 
 let cache: any
 const merge = Object.assign
-const isObject = (obj: unknown): obj is Obj => obj && typeof obj === 'object'
+const isObject = (obj: unknown): obj is Obj => !!obj && typeof obj === 'object'
 const isIterable = (obj: unknown): obj is Iterable =>
   isObject(obj) && typeof obj.map !== 'undefined'
 const isFieldArray = (field: unknown): field is Field =>
@@ -92,12 +92,12 @@ export function avdlToAVSC(path: any) {
 export async function avdlToAVSCAsync(path: string) {
   cache = {}
 
-  const protocol: { [key: string]: any } = await new Promise((resolve, reject) => {
+  const protocol: Record<string, any> = await new Promise((resolve, reject) => {
     assembleProtocol(path, (err: AssembleProtocolError, schema) => {
       if (err) {
         reject(new ConfluentSchemaRegistryError(`${err.message}. Caused by: ${err.path}`))
       } else {
-        resolve(schema)
+        resolve(schema as Record<string, any>)
       }
     })
   })

package/tmp/Array.avsc

@@ -0,0 +1,22 @@
+{
+  "type" : "record",
+  "name" : "Array",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "properties",
+    "type" : {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "KeyValue",
+        "fields" : [ {
+          "name" : "key",
+          "type" : "string"
+        }, {
+          "name" : "value",
+          "type" : "string"
+        } ]
+      }
+    }
+  } ]
+}

package/tmp/Array1.avsc

@@ -0,0 +1,28 @@
+{
+  "type" : "record",
+  "name" : "Array1",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "array2",
+    "type" : [ "null", {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "Array2",
+        "fields" : [ {
+          "name" : "array2_name",
+          "type" : "string"
+        }, {
+          "name" : "foos",
+          "type" : [ "null", {
+            "type" : "enum",
+            "name" : "Foos",
+            "symbols" : [ "foo", "bar", "baz" ]
+          } ],
+          "default" : null
+        } ]
+      }
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Array2.avsc

@@ -0,0 +1,17 @@
+{
+  "type" : "record",
+  "name" : "Array2",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "array2_name",
+    "type" : "string"
+  }, {
+    "name" : "foos",
+    "type" : [ "null", {
+      "type" : "enum",
+      "name" : "Foos",
+      "symbols" : [ "foo", "bar", "baz" ]
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Array3.avsc

@@ -0,0 +1,17 @@
+{
+  "type" : "record",
+  "name" : "Array3",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "bam",
+    "type" : [ "null", {
+      "type" : "record",
+      "name" : "Bam",
+      "fields" : [ {
+        "name" : "bam",
+        "type" : "string"
+      } ]
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/ArrayUnion.avsc

@@ -0,0 +1,23 @@
+{
+  "type" : "record",
+  "name" : "ArrayUnion",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "properties",
+    "type" : [ "null", {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "KeyValue",
+        "fields" : [ {
+          "name" : "key",
+          "type" : "string"
+        }, {
+          "name" : "value",
+          "type" : "string"
+        } ]
+      }
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Bam.avsc

@@ -0,0 +1,9 @@
+{
+  "type" : "record",
+  "name" : "Bam",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "bam",
+    "type" : "string"
+  } ]
+}

package/tmp/Bar.avsc

@@ -0,0 +1,46 @@
+{
+  "type" : "record",
+  "name" : "Bar",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "baz",
+    "type" : {
+      "type" : "record",
+      "name" : "Baz",
+      "fields" : [ {
+        "name" : "array1",
+        "type" : [ "null", {
+          "type" : "array",
+          "items" : {
+            "type" : "record",
+            "name" : "Array1",
+            "fields" : [ {
+              "name" : "array2",
+              "type" : [ "null", {
+                "type" : "array",
+                "items" : {
+                  "type" : "record",
+                  "name" : "Array2",
+                  "fields" : [ {
+                    "name" : "array2_name",
+                    "type" : "string"
+                  }, {
+                    "name" : "foos",
+                    "type" : [ "null", {
+                      "type" : "enum",
+                      "name" : "Foos",
+                      "symbols" : [ "foo", "bar", "baz" ]
+                    } ],
+                    "default" : null
+                  } ]
+                }
+              } ],
+              "default" : null
+            } ]
+          }
+        } ],
+        "default" : null
+      } ]
+    }
+  } ]
+}

package/tmp/Baz.avsc

@@ -0,0 +1,39 @@
+{
+  "type" : "record",
+  "name" : "Baz",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "array1",
+    "type" : [ "null", {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "Array1",
+        "fields" : [ {
+          "name" : "array2",
+          "type" : [ "null", {
+            "type" : "array",
+            "items" : {
+              "type" : "record",
+              "name" : "Array2",
+              "fields" : [ {
+                "name" : "array2_name",
+                "type" : "string"
+              }, {
+                "name" : "foos",
+                "type" : [ "null", {
+                  "type" : "enum",
+                  "name" : "Foos",
+                  "symbols" : [ "foo", "bar", "baz" ]
+                } ],
+                "default" : null
+              } ]
+            }
+          } ],
+          "default" : null
+        } ]
+      }
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Complex.avsc

@@ -0,0 +1,81 @@
+{
+  "type" : "record",
+  "name" : "Complex",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "array1",
+    "type" : [ "null", {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "Array1",
+        "fields" : [ {
+          "name" : "array2",
+          "type" : [ "null", {
+            "type" : "array",
+            "items" : {
+              "type" : "record",
+              "name" : "Array2",
+              "fields" : [ {
+                "name" : "array2_name",
+                "type" : "string"
+              }, {
+                "name" : "foos",
+                "type" : [ "null", {
+                  "type" : "enum",
+                  "name" : "Foos",
+                  "symbols" : [ "foo", "bar", "baz" ]
+                } ],
+                "default" : null
+              } ]
+            }
+          } ],
+          "default" : null
+        } ]
+      }
+    } ],
+    "default" : null
+  }, {
+    "name" : "array3",
+    "type" : {
+      "type" : "array",
+      "items" : {
+        "type" : "record",
+        "name" : "Array3",
+        "fields" : [ {
+          "name" : "bam",
+          "type" : [ "null", {
+            "type" : "record",
+            "name" : "Bam",
+            "fields" : [ {
+              "name" : "bam",
+              "type" : "string"
+            } ]
+          } ],
+          "default" : null
+        } ]
+      }
+    }
+  }, {
+    "name" : "bar",
+    "type" : {
+      "type" : "record",
+      "name" : "Bar",
+      "fields" : [ {
+        "name" : "baz",
+        "type" : {
+          "type" : "record",
+          "name" : "Baz",
+          "fields" : [ {
+            "name" : "array1",
+            "type" : [ "null", {
+              "type" : "array",
+              "items" : "Array1"
+            } ],
+            "default" : null
+          } ]
+        }
+      } ]
+    }
+  } ]
+}

package/tmp/Enum.avsc

@@ -0,0 +1,13 @@
+{
+  "type" : "record",
+  "name" : "Enum",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "foos",
+    "type" : {
+      "type" : "enum",
+      "name" : "Foos",
+      "symbols" : [ "foo", "bar", "baz" ]
+    }
+  } ]
+}

package/tmp/EnumUnion.avsc

@@ -0,0 +1,14 @@
+{
+  "type" : "record",
+  "name" : "EnumUnion",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "foos",
+    "type" : [ "null", {
+      "type" : "enum",
+      "name" : "Foos",
+      "symbols" : [ "foo", "bar", "baz" ]
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Foos.avsc

@@ -0,0 +1,6 @@
+{
+  "type" : "enum",
+  "name" : "Foos",
+  "namespace" : "com.org.app.track",
+  "symbols" : [ "foo", "bar", "baz" ]
+}

package/tmp/ImportMultipleNamespaces.avsc

@@ -0,0 +1,35 @@
+{
+  "type" : "record",
+  "name" : "ImportMultipleNamespaces",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "metadata",
+    "type" : {
+      "type" : "record",
+      "name" : "Metadata",
+      "namespace" : "com.org.messaging",
+      "fields" : [ {
+        "name" : "event_id",
+        "type" : "string"
+      }, {
+        "name" : "publisher_system_id",
+        "type" : "string"
+      }, {
+        "name" : "occurred_at",
+        "type" : {
+          "type" : "long",
+          "logicalType" : "timestamp-millis"
+        }
+      }, {
+        "name" : "published_at",
+        "type" : {
+          "type" : "long",
+          "logicalType" : "timestamp-millis"
+        }
+      }, {
+        "name" : "correlation_id",
+        "type" : "string"
+      } ]
+    }
+  } ]
+}

package/tmp/KeyValue.avsc

@@ -0,0 +1,12 @@
+{
+  "type" : "record",
+  "name" : "KeyValue",
+  "namespace" : "com.org.app.track",
+  "fields" : [ {
+    "name" : "key",
+    "type" : "string"
+  }, {
+    "name" : "value",
+    "type" : "string"
+  } ]
+}

package/tmp/Metadata.avsc

@@ -0,0 +1,27 @@
+{
+  "type" : "record",
+  "name" : "Metadata",
+  "namespace" : "com.org.messaging",
+  "fields" : [ {
+    "name" : "event_id",
+    "type" : "string"
+  }, {
+    "name" : "publisher_system_id",
+    "type" : "string"
+  }, {
+    "name" : "occurred_at",
+    "type" : {
+      "type" : "long",
+      "logicalType" : "timestamp-millis"
+    }
+  }, {
+    "name" : "published_at",
+    "type" : {
+      "type" : "long",
+      "logicalType" : "timestamp-millis"
+    }
+  }, {
+    "name" : "correlation_id",
+    "type" : "string"
+  } ]
+}

package/tmp/Multiple.avsc

@@ -0,0 +1,26 @@
+{
+  "type" : "record",
+  "name" : "Multiple",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "foo",
+    "type" : "string"
+  }, {
+    "name" : "bar",
+    "type" : {
+      "type" : "record",
+      "name" : "Bar",
+      "fields" : [ {
+        "name" : "baz",
+        "type" : {
+          "type" : "record",
+          "name" : "Baz",
+          "fields" : [ {
+            "name" : "bam",
+            "type" : "string"
+          } ]
+        }
+      } ]
+    }
+  } ]
+}

package/tmp/MultipleNamespaces.avsc

@@ -0,0 +1,44 @@
+{
+  "type" : "record",
+  "name" : "MultipleNamespaces",
+  "namespace" : "com.org.confluentschemaregistry",
+  "fields" : [ {
+    "name" : "metadata",
+    "type" : {
+      "type" : "record",
+      "name" : "Metadata",
+      "namespace" : "com.org.messaging",
+      "fields" : [ {
+        "name" : "event_id",
+        "type" : "string"
+      }, {
+        "name" : "publisher_system_id",
+        "type" : "string"
+      }, {
+        "name" : "occurred_at",
+        "type" : {
+          "type" : "long",
+          "logicalType" : "timestamp-millis"
+        }
+      }, {
+        "name" : "published_at",
+        "type" : {
+          "type" : "long",
+          "logicalType" : "timestamp-millis"
+        }
+      }, {
+        "name" : "correlation_id",
+        "type" : "string"
+      } ]
+    }
+  }, {
+    "name" : "id",
+    "type" : "string"
+  }, {
+    "name" : "amount",
+    "type" : "int"
+  }, {
+    "name" : "description",
+    "type" : "string"
+  } ]
+}

package/tmp/MultipleUnion.avsc

@@ -0,0 +1,28 @@
+{
+  "type" : "record",
+  "name" : "MultipleUnion",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "foo",
+    "type" : "string"
+  }, {
+    "name" : "bar",
+    "type" : [ "null", {
+      "type" : "record",
+      "name" : "Bar",
+      "fields" : [ {
+        "name" : "baz",
+        "type" : [ "null", {
+          "type" : "record",
+          "name" : "Baz",
+          "fields" : [ {
+            "name" : "bam",
+            "type" : "string"
+          } ]
+        } ],
+        "default" : null
+      } ]
+    } ],
+    "default" : null
+  } ]
+}

package/tmp/Simple.avsc

@@ -0,0 +1,9 @@
+{
+  "type" : "record",
+  "name" : "Simple",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "foo",
+    "type" : "string"
+  } ]
+}

package/tmp/Two.avsc

@@ -0,0 +1,19 @@
+{
+  "type" : "record",
+  "name" : "Two",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "foo",
+    "type" : "string"
+  }, {
+    "name" : "bar",
+    "type" : {
+      "type" : "record",
+      "name" : "Bar",
+      "fields" : [ {
+        "name" : "baz",
+        "type" : "string"
+      } ]
+    }
+  } ]
+}

package/tmp/Union.avsc

@@ -0,0 +1,20 @@
+{
+  "type" : "record",
+  "name" : "Union",
+  "namespace" : "com.org.domain.fixtures",
+  "fields" : [ {
+    "name" : "foo",
+    "type" : "string"
+  }, {
+    "name" : "bar",
+    "type" : [ "null", {
+      "type" : "record",
+      "name" : "Bar",
+      "fields" : [ {
+        "name" : "baz",
+        "type" : "string"
+      } ]
+    } ],
+    "default" : null
+  } ]
+}

package/dockest.ts

@@ -1,30 +0,0 @@
-import { Dockest, sleepWithLog, logLevel } from 'dockest'
-import { DockestService } from 'dockest/dist/@types'
-
-const dockest = new Dockest({
-  composeFile: 'docker-compose.yml',
-  dumpErrors: true,
-  jestLib: require('jest'),
-  jestOpts: {
-    updateSnapshot: true,
-  },
-  logLevel: logLevel.DEBUG,
-})
-
-const dockestServices: DockestService[] = [
-  {
-    serviceName: 'zooKeeper',
-    dependents: [
-      {
-        serviceName: 'kafka',
-        readinessCheck: () => sleepWithLog(10, `Sleeping for Kafka`),
-      },
-    ],
-  },
-  {
-    serviceName: 'schemaRegistry',
-    readinessCheck: () => sleepWithLog(35, `Sleeping for Schema Registry`),
-  },
-]
-
-dockest.run(dockestServices)