confluent-schema-registry 3.3.2

package/src/AvroHelper.ts

@@ -0,0 +1,91 @@
+import {
+  AvroSchema,
+  RawAvroSchema,
+  AvroOptions,
+  ConfluentSchema,
+  SchemaHelper,
+  ConfluentSubject,
+  ProtocolOptions,
+  AvroConfluentSchema,
+} from './@types'
+import { ConfluentSchemaRegistryArgumentError } from './errors'
+import avro, { ForSchemaOptions, Schema, Type } from 'avsc'
+import { SchemaResponse, SchemaType } from './@types'
+
+type TypeHook = (schema: Schema, opts: ForSchemaOptions) => Type
+export default class AvroHelper implements SchemaHelper {
+  private getRawAvroSchema(schema: ConfluentSchema): RawAvroSchema {
+    return (typeof schema.schema === 'string'
+      ? JSON.parse(schema.schema)
+      : schema.schema) as RawAvroSchema
+  }
+
+  public getAvroSchema(schema: ConfluentSchema | RawAvroSchema, opts?: AvroOptions) {
+    const rawSchema: RawAvroSchema = this.isRawAvroSchema(schema)
+      ? schema
+      : this.getRawAvroSchema(schema)
+    // @ts-ignore TODO: Fix typings for Schema...
+
+    const addReferencedSchemas = (userHook?: TypeHook): TypeHook => (
+      schema: avro.Schema,
+      opts: ForSchemaOptions,
+    ) => {
+      const avroOpts = opts as AvroOptions
+      avroOpts?.referencedSchemas?.forEach(subSchema => {
+        const rawSubSchema = this.getRawAvroSchema(subSchema)
+        avroOpts.typeHook = userHook
+        avro.Type.forSchema(rawSubSchema, avroOpts)
+      })
+      if (userHook) {
+        return userHook(schema, opts)
+      }
+    }
+
+    const avroSchema = avro.Type.forSchema(rawSchema, {
+      ...opts,
+      typeHook: addReferencedSchemas(opts?.typeHook),
+    })
+
+    return avroSchema
+  }
+
+  public validate(avroSchema: AvroSchema): void {
+    if (!avroSchema.name) {
+      throw new ConfluentSchemaRegistryArgumentError(`Invalid name: ${avroSchema.name}`)
+    }
+  }
+
+  public getSubject(
+    schema: AvroConfluentSchema,
+    // @ts-ignore
+    avroSchema: AvroSchema,
+    separator: string,
+  ): ConfluentSubject {
+    const rawSchema: RawAvroSchema = this.getRawAvroSchema(schema)
+
+    if (!rawSchema.namespace) {
+      throw new ConfluentSchemaRegistryArgumentError(`Invalid namespace: ${rawSchema.namespace}`)
+    }
+
+    const subject: ConfluentSubject = {
+      name: [rawSchema.namespace, rawSchema.name].join(separator),
+    }
+    return subject
+  }
+
+  private isRawAvroSchema(schema: ConfluentSchema | RawAvroSchema): schema is RawAvroSchema {
+    const asRawAvroSchema = schema as RawAvroSchema
+    return asRawAvroSchema.name != null && asRawAvroSchema.type != null
+  }
+
+  public toConfluentSchema(data: SchemaResponse): AvroConfluentSchema {
+    return { type: SchemaType.AVRO, schema: data.schema, references: data.references }
+  }
+
+  updateOptionsFromSchemaReferences(
+    referencedSchemas: AvroConfluentSchema[],
+    options: ProtocolOptions = {},
+  ): ProtocolOptions {
+    return { ...options, [SchemaType.AVRO]: { ...options[SchemaType.AVRO], referencedSchemas } }
+  }
+}

package/src/JsonHelper.ts

@@ -0,0 +1,35 @@
+import {
+  Schema,
+  SchemaHelper,
+  ConfluentSubject,
+  SchemaResponse,
+  SchemaType,
+  ProtocolOptions,
+  JsonConfluentSchema,
+} from './@types'
+import { ConfluentSchemaRegistryError } from './errors'
+
+export default class JsonHelper implements SchemaHelper {
+  public validate(_schema: Schema): void {
+    return
+  }
+
+  public getSubject(
+    _confluentSchema: JsonConfluentSchema,
+    _schema: Schema,
+    _separator: string,
+  ): ConfluentSubject {
+    throw new ConfluentSchemaRegistryError('not implemented yet')
+  }
+
+  public toConfluentSchema(data: SchemaResponse): JsonConfluentSchema {
+    return { type: SchemaType.JSON, schema: data.schema, references: data.references }
+  }
+
+  updateOptionsFromSchemaReferences(
+    referencedSchemas: JsonConfluentSchema[],
+    options: ProtocolOptions = {},
+  ): ProtocolOptions {
+    return { ...options, [SchemaType.JSON]: { ...options[SchemaType.JSON], referencedSchemas } }
+  }
+}

package/src/JsonSchema.ts

@@ -0,0 +1,80 @@
+import { Schema, JsonOptions, JsonConfluentSchema } from './@types'
+import Ajv from 'ajv'
+import { ConfluentSchemaRegistryValidationError } from './errors'
+
+interface BaseAjvValidationError {
+  data?: unknown
+  schema?: unknown
+}
+interface OldAjvValidationError extends BaseAjvValidationError {
+  dataPath: string
+  instancePath?: string
+}
+interface NewAjvValidationError extends BaseAjvValidationError {
+  instancePath: string
+}
+
+type AjvValidationError = OldAjvValidationError | NewAjvValidationError
+
+export interface ValidateFunction {
+  (this: any, data: any): boolean
+  errors?: null | AjvValidationError[]
+}
+export default class JsonSchema implements Schema {
+  private validate: ValidateFunction
+
+  constructor(schema: JsonConfluentSchema, opts?: JsonOptions) {
+    this.validate = this.getJsonSchema(schema, opts)
+  }
+
+  private getJsonSchema(schema: JsonConfluentSchema, opts?: JsonOptions) {
+    const ajv = opts?.ajvInstance ?? new Ajv(opts)
+    const referencedSchemas = opts?.referencedSchemas
+    if (referencedSchemas) {
+      referencedSchemas.forEach(rawSchema => {
+        const $schema = JSON.parse(rawSchema.schema)
+        ajv.addSchema($schema, $schema['$id'])
+      })
+    }
+    const validate = ajv.compile(JSON.parse(schema.schema))
+    return validate
+  }
+
+  private validatePayload(payload: any) {
+    const paths: string[][] = []
+    if (!this.isValid(payload, { errorHook: path => paths.push(path) })) {
+      throw new ConfluentSchemaRegistryValidationError('invalid payload', paths)
+    }
+  }
+
+  public toBuffer(payload: object): Buffer {
+    this.validatePayload(payload)
+    return Buffer.from(JSON.stringify(payload))
+  }
+
+  public fromBuffer(buffer: Buffer): any {
+    const payload = JSON.parse(buffer.toString())
+    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??[]) {
+          const path = this.isOldAjvValidationError(err) ? err.dataPath : err.instancePath
+          opts?.errorHook([path], err.data, err.schema)
+        }
+      }
+      return false
+    }
+    return true
+  }
+
+  private isOldAjvValidationError(error: AjvValidationError): error is OldAjvValidationError {
+    return (error as OldAjvValidationError).dataPath != null
+  }
+}

package/src/ProtoHelper.ts

@@ -0,0 +1,38 @@
+import {
+  Schema,
+  SchemaHelper,
+  ConfluentSubject,
+  SchemaResponse,
+  SchemaType,
+  ProtocolOptions,
+  ProtoConfluentSchema,
+} from './@types'
+import { ConfluentSchemaRegistryError } from './errors'
+
+export default class ProtoHelper implements SchemaHelper {
+  public validate(_schema: Schema): void {
+    return
+  }
+
+  public getSubject(
+    _confluentSchema: ProtoConfluentSchema,
+    _schema: Schema,
+    _separator: string,
+  ): ConfluentSubject {
+    throw new ConfluentSchemaRegistryError('not implemented yet')
+  }
+
+  public toConfluentSchema(data: SchemaResponse): ProtoConfluentSchema {
+    return { type: SchemaType.PROTOBUF, schema: data.schema, references: data.references }
+  }
+
+  updateOptionsFromSchemaReferences(
+    referencedSchemas: ProtoConfluentSchema[],
+    options: ProtocolOptions = {},
+  ): ProtocolOptions {
+    return {
+      ...options,
+      [SchemaType.PROTOBUF]: { ...options[SchemaType.PROTOBUF], referencedSchemas },
+    }
+  }
+}

package/src/ProtoSchema.ts

@@ -0,0 +1,80 @@
+import { Schema, ProtoOptions, ProtoConfluentSchema } from './@types'
+import protobuf from 'protobufjs'
+import { IParserResult, ReflectionObject, Namespace, Type } from 'protobufjs/light'
+import {
+  ConfluentSchemaRegistryArgumentError,
+  ConfluentSchemaRegistryValidationError,
+} from './errors'
+
+export default class ProtoSchema implements Schema {
+  private message: Type
+
+  constructor(schema: ProtoConfluentSchema, opts?: ProtoOptions) {
+    const parsedMessage = protobuf.parse(schema.schema)
+    const root = parsedMessage.root
+    const referencedSchemas = opts?.referencedSchemas
+
+    // handle all schema references independent on nested references
+    if (referencedSchemas) {
+      referencedSchemas.forEach(rawSchema => protobuf.parse(rawSchema.schema as string, root))
+    }
+
+    this.message = root.lookupType(this.getTypeName(parsedMessage, opts))
+  }
+
+  private getNestedTypeName(parent: { [k: string]: ReflectionObject } | undefined): string {
+    if (!parent) throw new ConfluentSchemaRegistryArgumentError('no nested fields')
+    const keys = Object.keys(parent)
+    const reflection = parent[keys[0]]
+
+    // Traverse down the nested Namespaces until we find a message Type instance (which extends Namespace)
+    if (reflection instanceof Namespace && !(reflection instanceof Type) && reflection.nested)
+      return this.getNestedTypeName(reflection.nested)
+    return keys[0]
+  }
+
+  private getTypeName(parsedMessage: IParserResult, opts?: ProtoOptions): string {
+    const root = parsedMessage.root
+    const pkg = parsedMessage.package
+    const name = opts && opts.messageName ? opts.messageName : this.getNestedTypeName(root.nested)
+    return `${pkg ? pkg + '.' : ''}.${name}`
+  }
+
+  private trimStart(buffer: Buffer): Buffer {
+    const index = buffer.findIndex((value: number) => value != 0)
+    return buffer.slice(index)
+  }
+
+  public toBuffer(payload: object): Buffer {
+    const paths: string[][] = []
+    if (
+      !this.isValid(payload, {
+        errorHook: (path: Array<string>) => paths.push(path),
+      })
+    ) {
+      throw new ConfluentSchemaRegistryValidationError('invalid payload', paths)
+    }
+
+    const protoPayload = this.message.create(payload)
+    return Buffer.from(this.message.encode(protoPayload).finish())
+  }
+
+  public fromBuffer(buffer: Buffer): any {
+    const newBuffer = this.trimStart(buffer)
+    return this.message.decode(newBuffer)
+  }
+
+  public isValid(
+    payload: object,
+    opts?: { errorHook: (path: Array<string>, value: any, type?: any) => void },
+  ): boolean {
+    const errMsg: null | string = this.message.verify(payload)
+    if (errMsg) {
+      if (opts?.errorHook) {
+        opts.errorHook([errMsg], payload)
+      }
+      return false
+    }
+    return true
+  }
+}