@biorate/schema-registry 2.2.1 → 3.0.0

package/dist/{index.js → cjs/index.js}

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./src"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{src → cjs/src}/api.js

@@ -1,9 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = void 0;
 const axios_prometheus_1 = require("@biorate/axios-prometheus");
-const avsc_1 = require("avsc");
+const avsc_1 = __importDefault(require("avsc"));
 const errors_1 = require("./errors");
+const AvroType = avsc_1.default.Type;
 const create = (config) => {
     const cache = new Map();
     class SchemaRegistryApi extends axios_prometheus_1.AxiosPrometheus {
@@ -159,7 +163,7 @@ const create = (config) => {
         const errors = [];
         const response = await GetSubjectsByVersion.fetch({ subject, version });
         const header = Buffer.alloc(5);
-        const schema = avsc_1.Type.forSchema(JSON.parse(response.data.schema));
+        const schema = AvroType.forSchema(JSON.parse(response.data.schema));
         schema.isValid(data, {
             errorHook: (path, value) => {
                 errors.push(`${path.join('.')}: ${value} (${typeof value})`);
@@ -175,10 +179,10 @@ const create = (config) => {
         let data = cache.get(id);
         if (!data) {
             const response = await GetSchemasById.fetch(id);
-            data = avsc_1.Type.forSchema(JSON.parse(response.data.schema));
+            data = AvroType.forSchema(JSON.parse(response.data.schema));
             cache.set(id, data);
         }
-        const schema = avsc_1.Type.forSchema(data);
+        const schema = AvroType.forSchema(data);
         return schema.fromBuffer(buffer.slice(5));
     }
     function toStringData(data) {
@@ -202,4 +206,3 @@ const create = (config) => {
     };
 };
 exports.create = create;
-//# sourceMappingURL=api.js.map

package/dist/{src → cjs/src}/errors.js

@@ -16,4 +16,3 @@ class SchemaRegistryAvroSchemaParseError extends errors_1.BaseError {
     }
 }
 exports.SchemaRegistryAvroSchemaParseError = SchemaRegistryAvroSchemaParseError;
-//# sourceMappingURL=errors.js.map

package/dist/{src → cjs/src}/index.js

@@ -48,4 +48,3 @@ exports.SchemaRegistryConnector = SchemaRegistryConnector;
 exports.SchemaRegistryConnector = SchemaRegistryConnector = __decorate([
     (0, inversion_1.injectable)()
 ], SchemaRegistryConnector);
-//# sourceMappingURL=index.js.map

package/dist/{src → cjs/src}/interfaces.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interfaces.js.map

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './src/index.js';

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/src/api.js

@@ -0,0 +1,201 @@
+import { AxiosPrometheus } from '@biorate/axios-prometheus';
+import avsc from 'avsc';
+import { SchemaRegistryAvroSchemaParseError } from './errors.js';
+const AvroType = avsc.Type;
+export const create = (config) => {
+    const cache = new Map();
+    class SchemaRegistryApi extends AxiosPrometheus {
+        constructor() {
+            super(...arguments);
+            this.baseURL = config.baseURL;
+            this.headers = config.headers;
+        }
+    }
+    class Ping extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/';
+            this.method = 'get';
+        }
+        static fetch() {
+            return this._fetch({});
+        }
+    }
+    class GetSchemasById extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/schemas/ids/:id';
+            this.method = 'get';
+        }
+        static fetch(id) {
+            return this._fetch({ path: { id } });
+        }
+    }
+    class GetSchemasTypes extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/schemas/types';
+            this.method = 'get';
+        }
+        static fetch() {
+            return this._fetch({});
+        }
+    }
+    class GetSchemasVersionsById extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/schemas/ids/:id/versions';
+            this.method = 'get';
+        }
+        static fetch(id) {
+            return this._fetch({ path: { id } });
+        }
+    }
+    class GetSubjects extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects';
+            this.method = 'get';
+        }
+        static fetch() {
+            return this._fetch({});
+        }
+    }
+    class GetSubjectsVersions extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject/versions';
+            this.method = 'get';
+        }
+        static fetch(subject) {
+            return this._fetch({ path: { subject } });
+        }
+    }
+    class DeleteSubjects extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject';
+            this.method = 'delete';
+        }
+        static fetch(data) {
+            return this._fetch({
+                path: { subject: data.subject },
+                params: { permanent: !!data.permanent },
+            });
+        }
+    }
+    class GetSubjectsByVersion extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject/versions/:version';
+            this.method = 'get';
+        }
+        static fetch(data) {
+            return this._fetch({ path: data });
+        }
+    }
+    class GetSchemaBySubjectsAndVersion extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject/versions/:version/schema';
+            this.method = 'get';
+        }
+        static fetch(data) {
+            return this._fetch({ path: data });
+        }
+    }
+    class PostSubjectsVersions extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject/versions';
+            this.method = 'post';
+        }
+        static fetch(data) {
+            return this._fetch({
+                path: { subject: data.subject },
+                params: { normalize: !!data.normalize },
+                data: {
+                    schema: toStringData(data.schema),
+                    schemaType: data.schemaType,
+                    reference: data.reference,
+                },
+            });
+        }
+    }
+    class PostSubjects extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/subjects/:subject';
+            this.method = 'post';
+        }
+        static fetch(data) {
+            return this._fetch({
+                path: { subject: data.subject },
+                params: { normalize: !!data.normalize },
+                data: {
+                    schema: toStringData(data.schema),
+                    schemaType: data.schemaType,
+                    reference: data.reference,
+                },
+            });
+        }
+    }
+    class PutConfig extends SchemaRegistryApi {
+        constructor() {
+            super(...arguments);
+            this.url = '/config/:subject';
+            this.method = 'put';
+        }
+        static fetch(data) {
+            return this._fetch({
+                path: { subject: data.subject },
+                data: { compatibility: data.compatibility },
+            });
+        }
+    }
+    async function encode(subject, data, version = 'latest') {
+        const errors = [];
+        const response = await GetSubjectsByVersion.fetch({ subject, version });
+        const header = Buffer.alloc(5);
+        const schema = AvroType.forSchema(JSON.parse(response.data.schema));
+        schema.isValid(data, {
+            errorHook: (path, value) => {
+                errors.push(`${path.join('.')}: ${value} (${typeof value})`);
+            },
+        });
+        if (errors.length)
+            throw new SchemaRegistryAvroSchemaParseError(errors);
+        header.writeInt32BE(response.data.id, 1);
+        return Buffer.concat([header, schema.toBuffer(data)]);
+    }
+    async function decode(buffer) {
+        const id = buffer.readInt32BE(1);
+        let data = cache.get(id);
+        if (!data) {
+            const response = await GetSchemasById.fetch(id);
+            data = AvroType.forSchema(JSON.parse(response.data.schema));
+            cache.set(id, data);
+        }
+        const schema = AvroType.forSchema(data);
+        return schema.fromBuffer(buffer.slice(5));
+    }
+    function toStringData(data) {
+        return typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    return {
+        ping: Ping.fetch.bind(Ping),
+        getSchemasById: (GetSchemasById.fetch.bind(GetSchemasById)),
+        getSchemasTypes: (GetSchemasTypes.fetch.bind(GetSchemasTypes)),
+        getSchemasVersionsById: (GetSchemasVersionsById.fetch.bind(GetSchemasVersionsById)),
+        getSubjects: GetSubjects.fetch.bind(GetSubjects),
+        getSubjectsVersions: (GetSubjectsVersions.fetch.bind(GetSubjectsVersions)),
+        deleteSubjects: (DeleteSubjects.fetch.bind(DeleteSubjects)),
+        getSubjectsByVersion: (GetSubjectsByVersion.fetch.bind(GetSubjectsByVersion)),
+        getSchemaBySubjectsAndVersion: (GetSchemaBySubjectsAndVersion.fetch.bind(GetSchemaBySubjectsAndVersion)),
+        postSubjects: PostSubjects.fetch.bind(PostSubjects),
+        postSubjectsVersions: (PostSubjectsVersions.fetch.bind(PostSubjectsVersions)),
+        putConfig: PutConfig.fetch.bind(PutConfig),
+        encode,
+        decode,
+    };
+};

package/dist/esm/src/errors.js

@@ -0,0 +1,13 @@
+import { BaseError } from '@biorate/errors';
+export class SchemaRegistryCantConnectError extends BaseError {
+    constructor(e) {
+        super(`Can't connect to schema registry: [%s]`, [e.message]);
+    }
+}
+export class SchemaRegistryAvroSchemaParseError extends BaseError {
+    constructor(errors) {
+        super('%s', [errors.join('; ')], {
+            status: 400,
+        });
+    }
+}

package/dist/esm/src/index.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from '@biorate/inversion';
+import { Connector } from '@biorate/connector';
+import { SchemaRegistryCantConnectError } from './errors.js';
+import { create } from './api.js';
+export * from './api.js';
+export * from './errors.js';
+export * from './interfaces.js';
+let SchemaRegistryConnector = class SchemaRegistryConnector extends Connector {
+    constructor() {
+        super(...arguments);
+        this.namespace = 'SchemaRegistry';
+    }
+    async connect(config) {
+        const connection = create(config);
+        try {
+            await connection.ping();
+        }
+        catch (e) {
+            throw new SchemaRegistryCantConnectError(e);
+        }
+        return connection;
+    }
+};
+SchemaRegistryConnector = __decorate([
+    injectable()
+], SchemaRegistryConnector);
+export { SchemaRegistryConnector };

package/dist/esm/src/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/types/src/api.d.ts

@@ -0,0 +1,61 @@
+import { ICompatibilities, ISchemaRegistryConfig } from './interfaces';
+export declare const create: (config: ISchemaRegistryConfig) => {
+    ping: () => Promise<import("@biorate/axios-prometheus").AxiosResponse<Record<string, unknown>, any, {}>>;
+    getSchemasById: (id: number) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        schema: string;
+    }, any, {}>>;
+    getSchemasTypes: () => Promise<import("@biorate/axios-prometheus").AxiosResponse<string[], any, {}>>;
+    getSchemasVersionsById: (id: number) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        subject: string;
+        version: number;
+    }[], any, {}>>;
+    getSubjects: () => Promise<import("@biorate/axios-prometheus").AxiosResponse<string[], any, {}>>;
+    getSubjectsVersions: (subject: string) => Promise<import("@biorate/axios-prometheus").AxiosResponse<number[], any, {}>>;
+    deleteSubjects: (data: {
+        subject: string;
+        permanent?: boolean;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<number[], any, {}>>;
+    getSubjectsByVersion: (data: {
+        subject: string;
+        version: number | string;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        subject: string;
+        id: number;
+        version: number;
+        schemaType: string;
+        schema: string;
+    }, any, {}>>;
+    getSchemaBySubjectsAndVersion: (data: {
+        subject: string;
+        version: number | string;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<unknown, any, {}>>;
+    postSubjects: (data: {
+        subject: string;
+        schema: string | Record<string, any>;
+        schemaType?: string;
+        reference?: string;
+        normalize?: boolean;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        subject: string;
+        id: number;
+        version: number;
+        schema: string;
+    }, any, {}>>;
+    postSubjectsVersions: (data: {
+        subject: string;
+        schema: string | Record<string, any>;
+        schemaType?: string;
+        reference?: string;
+        normalize?: boolean;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        id: number;
+    }, any, {}>>;
+    putConfig: (data: {
+        subject: string;
+        compatibility: ICompatibilities;
+    }) => Promise<import("@biorate/axios-prometheus").AxiosResponse<{
+        compatibility: ICompatibilities;
+    }, any, {}>>;
+    encode: (subject: string, data: Record<string, any>, version?: string | number) => Promise<Buffer>;
+    decode: (buffer: Buffer) => Promise<any>;
+};

package/dist/types/src/errors.d.ts

@@ -0,0 +1,7 @@
+import { BaseError } from '@biorate/errors';
+export declare class SchemaRegistryCantConnectError extends BaseError {
+    constructor(e: Error);
+}
+export declare class SchemaRegistryAvroSchemaParseError extends BaseError {
+    constructor(errors: string[]);
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,11 @@
+import { ISchemaRegistryConfig, ISchemaRegistryConnection } from './interfaces';
+import { Connector } from '@biorate/connector';
+export * from './api';
+export * from './errors';
+export * from './interfaces';
+export declare class SchemaRegistryConnector extends Connector<ISchemaRegistryConfig, ISchemaRegistryConnection> {
+    private '#connections';
+    private '#current';
+    protected readonly namespace = "SchemaRegistry";
+    protected connect(config: ISchemaRegistryConfig): Promise<ISchemaRegistryConnection>;
+}

package/dist/types/src/interfaces.d.ts

@@ -0,0 +1,9 @@
+import { IConnectorConfig, IConnector } from '@biorate/connector';
+import { create } from './api';
+export type ISchemaRegistryConnection = ReturnType<typeof create>;
+export interface ISchemaRegistryConfig extends IConnectorConfig {
+    baseURL: string;
+    headers: Record<string, string>;
+}
+export type ISchemaRegistryConnector = IConnector<ISchemaRegistryConfig, ISchemaRegistryConnection>;
+export type ICompatibilities = 'BACKWARD' | 'BACKWARD_TRANSITIVE' | 'FORWARD' | 'FORWARD_TRANSITIVE' | 'FULL' | 'FULL_TRANSITIVE' | 'NONE';

package/package.json

@@ -1,10 +1,35 @@
 {
   "name": "@biorate/schema-registry",
-  "version": "2.2.1",
+  "version": "3.0.0",
   "description": "Schema registry connector",
-  "main": "dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "build": "npx tsc -p ./tsconfig.build.json --outDir ./dist",
+    "clean": "cleanup dist",
+    "build:cjs": "npx tsc -p ./tsconfig.build.cjs.json",
+    "build:esm": "npx tsc -p ./tsconfig.build.esm.json",
+    "build:types": "npx tsc -p ./tsconfig.build.types.json",
+    "build": "pnpm run clean && pnpm run build:cjs && pnpm run build:esm && pnpm run build:types",
+    "postbuild:cjs": "node ../../../.scripts/write-package-type.js dist/cjs commonjs",
+    "postbuild:esm": "tsc-esm-fix --tsconfig=./tsconfig.build.esm.json --target=./dist/esm && node ../../../.scripts/write-package-type.js dist/esm module",
+    "format": "prettier --check src",
+    "lint": "eslint src --ext .ts",
+    "format:fix": "prettier --write src",
+    "lint:fix": "eslint src --ext .ts --fix",
     "test": "npx vitest run --coverage",
     "prepublishOnly": "pnpm run build"
   },
@@ -25,13 +50,13 @@
   ],
   "author": "llevkin",
   "license": "MIT",
+  "gitHead": "b2400d06c44d0cac2dd01440a6075a100702c278",
   "dependencies": {
-    "@biorate/axios-prometheus": "1.167.1",
-    "@biorate/config": "2.2.0",
-    "@biorate/connector": "2.2.0",
-    "@biorate/errors": "2.2.0",
-    "@biorate/inversion": "2.2.0",
+    "@biorate/axios-prometheus": "2.0.0",
+    "@biorate/config": "3.0.0",
+    "@biorate/connector": "3.0.0",
+    "@biorate/errors": "3.0.0",
+    "@biorate/inversion": "3.0.0",
     "avsc": "^5.7.4"
-  },
-  "gitHead": "00168f8350ace8f561f08800f8ef1e5ed61a364c"
+  }
 }

package/.nyc_output/2ab817d0-505c-454e-bed2-1750a6e607a4.json

@@ -1 +0,0 @@
-{}