Merge pull request #9 from debitoor/fix-review-comments-2

fix-review-comments-2

docs/schema-avro.md

@@ -31,9 +31,13 @@ You might want to split the Avro definition into several schemas one for each ty
 }
 ```
 
-To registry schemas with references they have to be registered in reverse order, so the referred schemas already exists. In this case B has to be registered before A. Furthermore A must define an array references to the referred schemas. A reference consist of a `name`, that should match the namespace + name, a schema `subject` and a schema `version`.
+To register schemas with references, the schemas have to be registered in reverse order. The schema that references another schema has to be registered after the schema it references. In this example B has to be registered before A. Furthermore, when registering A, a list of references have to be provided. A reference consist of:
 
-Notice the library will handle an arbitrary number of nested levels.
+ * `name` - the fully qualified name of the referenced schema. Example: `test.B`
+ * `subject` - the subject the schema is registered under in the registry
+ * `version` - the version of the schema you want to use
+
+The library will handle an arbitrary number of nested levels.
 
 ```js
 const schemaA = {

docs/schema-json.md

@@ -10,41 +10,45 @@ You might want to split the JSON definition into several schemas one for each ty
 
 ```JSON
 {
-	"$id": "https://sumup.com/schemas/A",
+	"$id": "https://example.com/schemas/A",
 	"type": "object",
 	"properties": {
 		"id": { "type": "number" },
-		"b": { "$ref": "https://sumup.com/schemas/B" }
+		"b": { "$ref": "https://example.com/schemas/B" }
 	}
 }
 ```
 
 ```JSON
 {
-	"$id": "https://sumup.com/schemas/B",
+	"$id": "https://example.com/schemas/B",
 	"type": "object",
 	"properties": {
 		"id": { "type": "number" }
 	}
 }
 ```
 
-To registry schemas with references they have to be registered in reverse order, so the referred schemas already exists. In this case B has to be registered before A. Furthermore A must define an array references to the referred schemas. A reference consist of a `name`, that should match the $ref, a schema `subject` and a schema `version`.
+To register schemas with references, the schemas have to be registered in reverse order. The schema that references another schema has to be registered after the schema it references. In this example B has to be registered before A. Furthermore, when registering A, a list of references have to be provided. A reference consist of:
 
-Notice the library will handle an arbitrary number of nested levels.
+ * `name` - A URL matching the `$ref` from the schema
+ * `subject` - the subject the schema is registered under in the registry
+ * `version` - the version of the schema you want to use
+
+The library will handle an arbitrary number of nested levels.
 
 ```js
 const schemaA = {
-	$id: 'https://sumup.com/schemas/A',
+	$id: 'https://example.com/schemas/A',
 	type: 'object',
 	properties: {
 		id: { type: 'number' },
-		b: { $ref: 'https://sumup.com/schemas/B' },
+		b: { $ref: 'https://example.com/schemas/B' },
 	},
 }
 
 const schemaB = {
-	$id: 'https://sumup.com/schemas/B',
+	$id: 'https://example.com/schemas/B',
 	type: 'object',
 	properties: {
 		id: { type: 'number' },
@@ -65,7 +69,7 @@ const { id } = await schemaRegistry.register(
 	schema: JSON.stringify(schemaA),
 	references: [
 	{
-		name: 'https://sumup.com/schemas/B',
+		name: 'https://example.com/schemas/B',
 		subject: 'JSON:B',
 		version,
 	},

docs/schema-protobuf.md

@@ -6,7 +6,7 @@ sidebar_label: Example Protobuf Schemas
 
 ## Schema with references to other schemas
 
-You might want to split the Protobuf definition into several schemas one for each type.
+You might want to split the Protobuf definition into several schemas, one for each type.
 
 ```protobuf
 syntax = "proto3";
@@ -28,9 +28,13 @@ message B {
 }
 ```
 
-To registry schemas with references they have to be registered in reverse order, so the referred schemas already exists. In this case B has to be registered before A. Furthermore A must define an array references to the referred schemas. A reference consist of a `name`, that should match the import statement, a schema `subject` and a schema `version`.
+To register schemas with references, the schemas have to be registered in reverse order. The schema that references another schema has to be registered after the schema it references. In this example B has to be registered before A. Furthermore, when registering A, a list of references have to be provided. A reference consist of:
 
-Notice the library will handle an arbitrary number of nested levels.
+ * `name` - String matching the import statement. For example: `test/B.proto`
+ * `subject` - the subject the schema is registered under in the registry
+ * `version` - the version of the schema you want to use
+
+The library will handle an arbitrary number of nested levels.
 
 ```js
 const schemaA = `

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafkajs/confluent-schema-registry",
-  "version": "3.3.0",
+  "version": "3.2.1",
   "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": [

src/@types.ts

@@ -13,21 +13,21 @@ export interface SchemaHelper {
   getSubject(confluentSchema: ConfluentSchema, schema: Schema, separator: string): ConfluentSubject
   toConfluentSchema(data: SchemaResponse): ConfluentSchema
   updateOptionsFromSchemaReferences(
-    options: ProtocolOptions,
-    referredSchemas: ConfluentSchema[],
+    referencedSchemas: ConfluentSchema[],
+    options?: ProtocolOptions,
   ): ProtocolOptions
 }
 
 export type AvroOptions = Partial<ForSchemaOptions> & {
-  referredSchemas?: AvroConfluentSchema[]
+  referencedSchemas?: AvroConfluentSchema[]
 }
 export type JsonOptions = ConstructorParameters<typeof Ajv>[0] & {
   ajvInstance?: {
     compile: (schema: any) => ValidateFunction
   }
-  referredSchemas?: JsonConfluentSchema[]
+  referencedSchemas?: JsonConfluentSchema[]
 }
-export type ProtoOptions = { messageName?: string; referredSchemas?: ProtoConfluentSchema[] }
+export type ProtoOptions = { messageName?: string; referencedSchemas?: ProtoConfluentSchema[] }
 
 export interface LegacyOptions {
   forSchemaOptions?: AvroOptions
@@ -67,28 +67,28 @@ export interface ConfluentSubject {
 export interface AvroConfluentSchema {
   type: SchemaType.AVRO
   schema: string | RawAvroSchema
-  references?: ReferenceType[]
+  references?: SchemaReference[]
 }
 
-export type ReferenceType = {
+export type SchemaReference = {
   name: string
   subject: string
   version: number
 }
 export interface ProtoConfluentSchema {
   type: SchemaType.PROTOBUF
   schema: string
-  references?: ReferenceType[]
+  references?: SchemaReference[]
 }
 export interface JsonConfluentSchema {
   type: SchemaType.JSON
   schema: string
-  references?: ReferenceType[]
+  references?: SchemaReference[]
 }
 export interface SchemaResponse {
   schema: string
   schemaType: string
-  references?: ReferenceType[]
+  references?: SchemaReference[]
 }
 
 export type ConfluentSchema = AvroConfluentSchema | ProtoConfluentSchema | JsonConfluentSchema

src/AvroHelper.ts

@@ -26,12 +26,12 @@ export default class AvroHelper implements SchemaHelper {
       : this.getRawAvroSchema(schema)
     // @ts-ignore TODO: Fix typings for Schema...
 
-    const addReferredSchemas = (userHook?: TypeHook): TypeHook => (
+    const addReferencedSchemas = (userHook?: TypeHook): TypeHook => (
       schema: avro.Schema,
       opts: ForSchemaOptions,
     ) => {
       const avroOpts = opts as AvroOptions
-      avroOpts?.referredSchemas?.forEach(subSchema => {
+      avroOpts?.referencedSchemas?.forEach(subSchema => {
         const rawSubSchema = this.getRawAvroSchema(subSchema)
         avroOpts.typeHook = userHook
         avro.Type.forSchema(rawSubSchema, avroOpts)
@@ -43,7 +43,7 @@ export default class AvroHelper implements SchemaHelper {
 
     const avroSchema = avro.Type.forSchema(rawSchema, {
       ...opts,
-      typeHook: addReferredSchemas(opts?.typeHook),
+      typeHook: addReferencedSchemas(opts?.typeHook),
     })
 
     return avroSchema
@@ -83,10 +83,9 @@ export default class AvroHelper implements SchemaHelper {
   }
 
   updateOptionsFromSchemaReferences(
-    options: ProtocolOptions,
-    referredSchemas: AvroConfluentSchema[],
+    referencedSchemas: AvroConfluentSchema[],
+    options: ProtocolOptions = {},
   ): ProtocolOptions {
-    const opts = options ?? {}
-    return { ...opts, [SchemaType.AVRO]: { ...opts[SchemaType.AVRO], referredSchemas } }
+    return { ...options, [SchemaType.AVRO]: { ...options[SchemaType.AVRO], referencedSchemas } }
   }
 }

src/JsonHelper.ts

@@ -27,10 +27,9 @@ export default class JsonHelper implements SchemaHelper {
   }
 
   updateOptionsFromSchemaReferences(
-    options: ProtocolOptions,
-    referredSchemas: JsonConfluentSchema[],
+    referencedSchemas: JsonConfluentSchema[],
+    options: ProtocolOptions = {},
   ): ProtocolOptions {
-    const opts = options ?? {}
-    return { ...opts, [SchemaType.JSON]: { ...opts[SchemaType.JSON], referredSchemas } }
+    return { ...options, [SchemaType.JSON]: { ...options[SchemaType.JSON], referencedSchemas } }
   }
 }

src/JsonSchema.ts

@@ -29,9 +29,9 @@ export default class JsonSchema implements Schema {
 
   private getJsonSchema(schema: JsonConfluentSchema, opts?: JsonOptions) {
     const ajv = opts?.ajvInstance ?? new Ajv(opts)
-    const referredSchemas = opts?.referredSchemas
-    if (referredSchemas) {
-      referredSchemas.forEach(rawSchema => {
+    const referencedSchemas = opts?.referencedSchemas
+    if (referencedSchemas) {
+      referencedSchemas.forEach(rawSchema => {
         const $schema = JSON.parse(rawSchema.schema)
         // @ts-ignore
         ajv.addSchema($schema, $schema['$id'])

src/ProtoHelper.ts

@@ -27,10 +27,12 @@ export default class ProtoHelper implements SchemaHelper {
   }
 
   updateOptionsFromSchemaReferences(
-    options: ProtocolOptions,
-    referredSchemas: ProtoConfluentSchema[],
+    referencedSchemas: ProtoConfluentSchema[],
+    options: ProtocolOptions = {},
   ): ProtocolOptions {
-    const opts = options ?? {}
-    return { ...opts, [SchemaType.PROTOBUF]: { ...opts[SchemaType.PROTOBUF], referredSchemas } }
+    return {
+      ...options,
+      [SchemaType.PROTOBUF]: { ...options[SchemaType.PROTOBUF], referencedSchemas },
+    }
   }
 }

src/ProtoSchema.ts

@@ -12,11 +12,11 @@ export default class ProtoSchema implements Schema {
   constructor(schema: ProtoConfluentSchema, opts?: ProtoOptions) {
     const parsedMessage = protobuf.parse(schema.schema)
     const root = parsedMessage.root
-    const referredSchemas = opts?.referredSchemas
+    const referencedSchemas = opts?.referencedSchemas
 
     // handle all schema references independent on nested references
-    if (referredSchemas) {
-      referredSchemas.forEach(rawSchema => protobuf.parse(rawSchema.schema as string, root))
+    if (referencedSchemas) {
+      referencedSchemas.forEach(rawSchema => protobuf.parse(rawSchema.schema as string, root))
     }
 
     this.message = root.lookupType(this.getTypeName(parsedMessage, opts))

src/SchemaRegistry.avro.spec.ts

@@ -509,6 +509,39 @@ describe('SchemaRegistry', () => {
         ;({ schema } = await schemaRegistry['_getSchema'](registeredSchema.id))
       })
 
+      it('should be able to encode/decode enums schemas', async () => {
+        const obj = {
+          direction: Direction.UP,
+          attributes: { color: Color.BLUE },
+        }
+
+        const buffer = await schema.toBuffer(obj)
+        const resultObj = await schema.fromBuffer(buffer)
+
+        expect(resultObj).toEqual(obj)
+      })
+    })
+    describe('with enum typeHook defined as LegacyOptions', () => {
+      beforeEach(async () => {
+        const schemaRegistry = new SchemaRegistry(schemaRegistryArgs, {
+          forSchemaOptions: { typeHook },
+        })
+
+        await schemaRegistry.register(TestSchemas.EnumSchema, {
+          subject: 'Avro:EnumSchema',
+        })
+
+        const latest = apiResponse(await api.Subject.latestVersion({ subject: 'Avro:EnumSchema' }))
+        TestSchemas.EnumWithReferencesSchema.references[0].version = latest.version
+        const registeredSchema = await schemaRegistry.register(
+          TestSchemas.EnumWithReferencesSchema,
+          {
+            subject: 'Avro:EnumWithReferences',
+          },
+        )
+        ;({ schema } = await schemaRegistry['_getSchema'](registeredSchema.id))
+      })
+
       it('should be able to encode/decode enums schemas', async () => {
         const obj = {
           direction: Direction.UP,