@tsofist/schema-forge 2.9.0 → 2.10.0-next.1

package/lib/{generator → schema-generator}/types.js

@@ -1,20 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SG_CONFIG_DEFAULTS = exports.SG_CONFIG_MANDATORY = exports.TMP_FILES_SUFFIX = void 0;
+exports.SFG_CONFIG_MANDATORY = exports.SFG_CONFIG_DEFAULTS = exports.TMP_FILES_SUFFIX = void 0;
 exports.TMP_FILES_SUFFIX = '.schema-forge.temporary-generated.tmp';
-exports.SG_CONFIG_MANDATORY = {
-    jsDoc: 'extended',
-    topRef: true,
-    skipTypeCheck: false,
-};
-exports.SG_CONFIG_DEFAULTS = {
+exports.SFG_CONFIG_DEFAULTS = {
     sortProps: true,
     additionalProperties: false,
     expose: 'export',
     strictTuples: true,
-    extraTags: ['member', 'method', 'interface', 'property', 'dbIndex', 'dbEntity', 'faker'],
+    extraTags: [
+        //
+        'apiMember',
+        'apiMethod',
+        'apiInterface',
+        'apiProperty',
+        //
+        'dbColumn',
+        'dbIndex',
+        'dbEntity',
+        //
+        'faker',
+    ],
     encodeRefs: false,
     markdownDescription: false,
     discriminatorType: undefined,
     functions: 'hide',
 };
+exports.SFG_CONFIG_MANDATORY = {
+    jsDoc: 'extended',
+    topRef: true,
+    skipTypeCheck: false,
+};

package/lib/schema-registry/kw-api.d.ts

@@ -0,0 +1,3 @@
+import type { KeywordDefinition } from 'ajv';
+export declare const SFRAPIDefinitionKeywords: readonly KeywordDefinition[];
+//# sourceMappingURL=kw-api.d.ts.map

package/lib/schema-registry/kw-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kw-api.d.ts","sourceRoot":"","sources":["../../src/schema-registry/kw-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,KAAK,CAAC;AAO7C,eAAO,MAAM,wBAAwB,EAAE,SAAS,iBAAiB,EAiBvD,CAAC"}

package/lib/schema-registry/kw-api.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFRAPIDefinitionKeywords = void 0;
+const NP_API_INTERFACE = '^[A-Z][a-zA-Z0-9]+$';
+const NP_API_PROP = '^[a-z][a-zA-Z0-9]+$';
+const NP_API_METHOD = NP_API_PROP;
+const NP_API_MEMBER = `${NP_API_INTERFACE.substring(0, NP_API_INTERFACE.length - 1)}#${NP_API_PROP.substring(1)}`;
+exports.SFRAPIDefinitionKeywords = [
+    {
+        keyword: ['interface', 'apiInterface'],
+        metaSchema: { type: 'string', pattern: NP_API_INTERFACE },
+    },
+    {
+        keyword: ['property', 'apiProperty'],
+        metaSchema: { type: 'string', pattern: NP_API_PROP },
+    },
+    {
+        keyword: ['method', 'apiMethod'],
+        metaSchema: { type: 'string', pattern: NP_API_METHOD },
+    },
+    {
+        keyword: ['member', 'apiMember'],
+        metaSchema: { type: 'string', pattern: NP_API_MEMBER },
+    },
+];

package/lib/schema-registry/kw-common.d.ts

@@ -0,0 +1,3 @@
+import type { KeywordDefinition } from 'ajv';
+export declare const SFRCommonKeywords: readonly KeywordDefinition[];
+//# sourceMappingURL=kw-common.d.ts.map

package/lib/schema-registry/kw-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kw-common.d.ts","sourceRoot":"","sources":["../../src/schema-registry/kw-common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,KAAK,CAAC;AAI7C,eAAO,MAAM,iBAAiB,EAAE,SAAS,iBAAiB,EA0ChD,CAAC"}

package/lib/schema-registry/kw-common.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFRCommonKeywords = void 0;
+const FakerModulePattern = '^[a-zA-Z.]+$';
+exports.SFRCommonKeywords = [
+    {
+        keyword: 'version',
+        dependencies: ['$id', '$schema'],
+        metaSchema: { type: 'string' },
+    },
+    {
+        keyword: 'hash',
+        dependencies: ['$id', '$schema'],
+        metaSchema: { type: 'string' },
+    },
+    {
+        keyword: 'faker',
+        metaSchema: {
+            oneOf: [
+                {
+                    // https://fakerjs.dev/api/person.html
+                    // https://fakerjs.dev/api/company.html#name
+                    // https://github.com/json-schema-faker/json-schema-faker/blob/master/docs/USAGE.md
+                    // example (schema):
+                    //   faker: 'person.fullName'
+                    //   faker: 'person.firstName'
+                    //   faker: 'company.name'
+                    // example (jsdoc):
+                    //   @faker company.name
+                    type: 'string',
+                    pattern: FakerModulePattern,
+                },
+                {
+                    // https://fakerjs.dev/api/lorem.html#words
+                    // example (schema):
+                    //   faker: { 'lorem.words': [{ min: 30, max: 50 }] },
+                    // example (jsdoc):
+                    //   @faker { 'lorem.words': [{ min: 5, max: 10 }] }
+                    type: 'object',
+                    propertyNames: {
+                        pattern: FakerModulePattern,
+                    },
+                },
+            ],
+        },
+    },
+];

package/lib/schema-registry/kw-dbml.d.ts

@@ -0,0 +1,3 @@
+import { type KeywordDefinition } from 'ajv';
+export declare const SFRDBMLKeywords: readonly KeywordDefinition[];
+//# sourceMappingURL=kw-dbml.d.ts.map

package/lib/schema-registry/kw-dbml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kw-dbml.d.ts","sourceRoot":"","sources":["../../src/schema-registry/kw-dbml.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,KAAK,CAAC;AA6C7C,eAAO,MAAM,eAAe,EAAE,SAAS,iBAAiB,EA0C9C,CAAC"}

package/lib/schema-registry/kw-dbml.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFRDBMLKeywords = void 0;
+const types_1 = require("../dbml-generator/types");
+const NP_IX = '^ix_[a-z][a-zA-Z0-9_]+$';
+const NP_ENTITY = '^([a-zA-Z_][a-z0-9_]*\\.)?[a-z_][a-z0-9_]*$';
+const NP_NESTED_PROP = '^[a-z][a-zA-Z0-9.-]+$';
+const DBMLIndexOptionsProperties = {
+    name: { type: 'string', pattern: NP_IX },
+    unique: { type: 'boolean' },
+    pk: { type: 'boolean' },
+    type: {
+        type: 'string',
+        enum: types_1.DBMLIndexTypeList,
+    },
+    note: { type: 'string' },
+    comment: { type: 'string' },
+};
+const DBMLIndexSchema = {
+    type: ['string', 'boolean', 'object', 'array'],
+    pattern: NP_IX,
+    additionalProperties: false,
+    properties: DBMLIndexOptionsProperties,
+    items: {},
+    minItems: 1,
+    examples: [
+        true,
+        false,
+        `ix_my_index`,
+        `{ unique: true, name: 'ix_my_index', note: 'This is important' }`,
+    ],
+};
+DBMLIndexSchema.items = {
+    ...DBMLIndexSchema,
+    type: ['string', 'boolean', 'object'],
+};
+exports.SFRDBMLKeywords = [
+    {
+        keyword: 'dbIndex',
+        metaSchema: DBMLIndexSchema,
+    },
+    {
+        keyword: 'dbColumn',
+        metaSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                pk: { type: 'boolean' },
+                type: { enum: types_1.DBMLColumnTypeList },
+                // name: { type: 'string' }, todo
+            },
+        },
+    },
+    {
+        keyword: 'dbEntity',
+        metaSchema: {
+            type: ['string', 'object'],
+            pattern: NP_ENTITY,
+            additionalProperties: false,
+            properties: {
+                name: { type: 'string', pattern: NP_ENTITY },
+                indexes: {
+                    type: 'object',
+                    additionalProperties: DBMLIndexSchema,
+                    propertyNames: { pattern: NP_NESTED_PROP },
+                },
+                note: { type: 'string' },
+                comment: { type: 'string' },
+                alias: { type: 'string' },
+                settings: {
+                    type: 'object',
+                    properties: {
+                        headercolor: { type: 'string' },
+                    },
+                },
+            },
+        },
+    },
+];

package/lib/schema-registry/loader.d.ts

@@ -0,0 +1,10 @@
+import type { JSONSchema7Object } from 'json-schema';
+/**
+ * Load JSON schema files
+ */
+export declare function loadJSONSchema(files: string[]): Promise<JSONSchema7Object[]>;
+/**
+ * Load JSON schema files synchronously
+ */
+export declare function loadJSONSchemaSync(files: string[]): JSONSchema7Object[];
+//# sourceMappingURL=loader.d.ts.map

package/lib/schema-registry/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/schema-registry/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;GAEG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAOlF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAKvE"}

package/lib/schema-registry/loader.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJSONSchema = loadJSONSchema;
+exports.loadJSONSchemaSync = loadJSONSchemaSync;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+/**
+ * Load JSON schema files
+ */
+async function loadJSONSchema(files) {
+    return Promise.all(files.map(async (fn) => {
+        const raw = await (0, promises_1.readFile)(fn, { encoding: 'utf8' });
+        return JSON.parse(raw);
+    }));
+}
+/**
+ * Load JSON schema files synchronously
+ */
+function loadJSONSchemaSync(files) {
+    return files.map((fn) => {
+        const raw = (0, node_fs_1.readFileSync)(fn, { encoding: 'utf8' });
+        return JSON.parse(raw);
+    });
+}

package/lib/schema-registry/registry.d.ts

@@ -0,0 +1,25 @@
+import { type Options as AjvOptions } from 'ajv';
+import { SchemaForgeRegistry } from './types';
+interface SFROptions {
+    /**
+     * Extra ajv options
+     *
+     * @see https://ajv.js.org/options.html Options reference
+     * @see https://ajv.js.org/json-schema.html Schema reference
+     */
+    engine?: AjvOptions;
+    /**
+     * Use additional formats via ajv-formats
+     *
+     * @see https://ajv.js.org/packages/ajv-formats.html ajv-formats
+     */
+    extendedVocabulary?: boolean;
+}
+/**
+ * Create JSON schema data validation registry
+ *
+ * @see https://ajv.js.org/json-schema.html ajv
+ */
+export declare function createSchemaForgeRegistry(options?: SFROptions): SchemaForgeRegistry;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/lib/schema-registry/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/schema-registry/registry.ts"],"names":[],"mappings":"AAOA,OAAY,EAGR,KAAK,OAAO,IAAI,UAAU,EAE7B,MAAM,KAAK,CAAC;AAiBb,OAAO,EAAE,mBAAmB,EAA+C,MAAM,SAAS,CAAC;AAsB3F,UAAU,UAAU;IAChB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,mBAAmB,CAkOnF"}

package/lib/schema-registry/registry.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchemaForgeRegistry = createSchemaForgeRegistry;
+const as_array_1 = require("@tsofist/stem/lib/as-array");
+const chunk_1 = require("@tsofist/stem/lib/chunk");
+const error_1 = require("@tsofist/stem/lib/error");
+const entries_1 = require("@tsofist/stem/lib/object/entries");
+const values_1 = require("@tsofist/stem/lib/object/values");
+const delay_1 = require("@tsofist/stem/lib/timers/delay");
+const ajv_1 = require("ajv");
+const ajv_formats_1 = require("ajv-formats");
+const parser_1 = require("../definition-info/parser");
+const ref_1 = require("../definition-info/ref");
+const efc_1 = require("../efc");
+const types_1 = require("../schema-generator/types");
+const kw_api_1 = require("./kw-api");
+const kw_common_1 = require("./kw-common");
+const kw_dbml_1 = require("./kw-dbml");
+const SFR_DEFAULT_OPTIONS = {
+    meta: true,
+    defaultMeta: 'http://json-schema.org/draft-07/schema',
+    allErrors: true,
+    strict: true,
+    strictSchema: true,
+    strictTypes: false,
+    strictTuples: false,
+    allowUnionTypes: true,
+    coerceTypes: false,
+    removeAdditional: false,
+    unicodeRegExp: true,
+    useDefaults: false,
+    addUsedSchema: false,
+    inlineRefs: true,
+    ownProperties: true,
+    discriminator: false,
+    code: { es5: false, esm: false, optimize: 2 },
+};
+/**
+ * Create JSON schema data validation registry
+ *
+ * @see https://ajv.js.org/json-schema.html ajv
+ */
+function createSchemaForgeRegistry(options) {
+    const engineOptions = { ...SFR_DEFAULT_OPTIONS, ...options?.engine };
+    const useAdditionalFormats = options?.extendedVocabulary ?? true;
+    const initialSchemas = engineOptions.schemas;
+    if (initialSchemas)
+        delete engineOptions.schemas;
+    let rev = 0;
+    let engine = new ajv_1.default(engineOptions);
+    engine.removeSchema();
+    if (initialSchemas)
+        engine.addSchema(initialSchemas);
+    addJSDocKeywords(engine);
+    if (useAdditionalFormats)
+        engine = (0, ajv_formats_1.default)(engine);
+    function clone(options, onSchema) {
+        const schemas = [];
+        for (const env of (0, values_1.nonNullableValues)(engine.schemas)) {
+            if (env.meta)
+                continue;
+            const schema = onSchema
+                ? onSchema(env.schema)
+                : env.schema;
+            schemas.push(schema);
+        }
+        const opts = {
+            ...options,
+            schemas,
+            ...options,
+        };
+        return createSchemaForgeRegistry({
+            engine: opts,
+            extendedVocabulary: useAdditionalFormats,
+        });
+    }
+    function getValidator(ref) {
+        if (typeof ref === 'string')
+            return engine.getSchema(ref);
+        const result = engine.compile(ref);
+        checkIsSyncValidator(result);
+        return result;
+    }
+    function hasSchema(ref) {
+        return ref in engine.schemas || ref in engine.refs || engine.getSchema(ref) != null;
+    }
+    function addSchema(schema) {
+        engine.addSchema(schema);
+        rev++;
+    }
+    function removeSchema(ref) {
+        for (const item of (0, as_array_1.asArray)(ref))
+            engine.removeSchema(item);
+        rev++;
+    }
+    function clear() {
+        engine.removeSchema();
+        rev++;
+    }
+    function validationErrorsText(errors, options) {
+        return engine.errorsText(errors, options);
+    }
+    function validateBySchema(ref, data, instancePath = '') {
+        const validator = getValidator(ref);
+        if (!validator) {
+            return efc_1.SchemaForgeErrors.raise(efc_1.SchemaForgeErrors.EC_SF_SCHEMA_NOT_FOUND, {
+                schema: ref,
+                instancePath,
+            });
+        }
+        const valid = validator(data, {
+            instancePath,
+            parentData: {},
+            parentDataProperty: '',
+            rootData: {},
+            dynamicAnchors: {},
+        });
+        const errors = validator.errors;
+        return {
+            valid,
+            errors,
+            errorsText(options) {
+                return validationErrorsText(errors, options);
+            },
+        };
+    }
+    function checkBySchema(ref, data, context) {
+        const result = validateBySchema(ref, data, context?.instancePath);
+        if (!result.valid) {
+            efc_1.SchemaForgeErrors.raise(efc_1.SchemaForgeErrors.EC_SF_VALIDATION_FAILED, {
+                ...context,
+                schema: ref,
+                errors: result.errors,
+            });
+        }
+        return result.valid;
+    }
+    function mapDefinitions(callback) {
+        const result = [];
+        for (const [schemaId, env] of (0, entries_1.entries)(engine.schemas)) {
+            if (env &&
+                typeof env.schema === 'object' &&
+                !schemaId.startsWith('http') &&
+                env.schema.definitions &&
+                typeof env.schema.definitions === 'object') {
+                for (const [name, def] of Object.entries(env.schema.definitions)) {
+                    result.push(callback(name, schemaId, def));
+                }
+            }
+        }
+        return result;
+    }
+    function readSchemaKeywords(schema) {
+        const result = new Set();
+        for (const tag of types_1.SFG_CONFIG_DEFAULTS.extraTags) {
+            if (tag in schema)
+                result.add(tag);
+        }
+        return result;
+    }
+    function listDefinitions(predicate) {
+        const result = [];
+        mapDefinitions((name, schemaId, schema) => {
+            const info = (0, parser_1.parseSchemaDefinitionInfo)(name, schemaId);
+            if (predicate === undefined || predicate(info, readSchemaKeywords(schema))) {
+                result.push(info);
+            }
+        });
+        return result;
+    }
+    function getSchema(ref) {
+        return getValidator(ref)?.schema;
+    }
+    function getRootSchema(schemaId) {
+        return engine.schemas[schemaId]?.schema;
+    }
+    function warmupCacheSync() {
+        mapDefinitions((name, schemaId) => {
+            const ref = (0, ref_1.buildSchemaDefinitionRef)(name, schemaId);
+            checkIsSyncValidator(engine.getSchema(ref));
+        });
+    }
+    async function warmupCache(schemasPerIteration = 5, delayMs = 1) {
+        await (0, chunk_1.chunk)(mapDefinitions((name, schemaId) => (0, ref_1.buildSchemaDefinitionRef)(name, schemaId)), schemasPerIteration, async (items) => {
+            for (const ref of items)
+                engine.getSchema(ref);
+            return (0, delay_1.delay)(delayMs);
+        });
+    }
+    return {
+        get compilationArtifactCount() {
+            const names = new Set([
+                //
+                ...Object.keys(engine.refs),
+                ...Object.keys(engine.schemas),
+            ]);
+            return names.size;
+        },
+        get rev() {
+            return rev;
+        },
+        clear,
+        clone,
+        getRootSchema,
+        addSchema,
+        getSchema,
+        hasSchema,
+        removeSchema,
+        getValidator,
+        validationErrorsText,
+        validateBySchema,
+        checkBySchema,
+        listDefinitions,
+        warmupCache,
+        warmupCacheSync,
+    };
+}
+function addJSDocKeywords(engine) {
+    engine.addVocabulary([
+        //
+        ...kw_common_1.SFRCommonKeywords,
+        ...kw_api_1.SFRAPIDefinitionKeywords,
+        ...kw_dbml_1.SFRDBMLKeywords,
+    ]);
+}
+function checkIsSyncValidator(fn) {
+    if (typeof fn === 'function' && '$async' in fn) {
+        (0, error_1.raise)('[SchemaForge] Asynchronous validation schemas are not supported');
+    }
+}

package/lib/schema-registry/types.d.ts

@@ -0,0 +1,78 @@
+import type { ArrayMay, Nullable } from '@tsofist/stem';
+import type { NonNegativeInt } from '@tsofist/stem/lib/number/integer/types';
+import type { ErrorsTextOptions, Options } from 'ajv';
+import type { JSONSchema7, JSONSchema7Object } from 'json-schema';
+import type { SchemaDefinitionInfo } from '../definition-info/types';
+import type { SchemaForgeValidationContextBase } from '../efc';
+import type { SchemaForgeDefinitionRef, SchemaForgeValidationFunction, SchemaForgeValidationReport, SchemaForgeValidationResult } from '../types';
+export type SchemaForgeRegistryListDefinitionsPredicate = (info: SchemaDefinitionInfo, keywords: Set<string>) => boolean;
+export interface SchemaForgeRegistry {
+    /**
+     * Number of compiled schemas in registry
+     */
+    readonly compilationArtifactCount: NonNegativeInt;
+    /**
+     * Revision number of registry.
+     * This number is represented as a number of add/remove/clear operations.
+     */
+    readonly rev: NonNegativeInt;
+    /**
+     * Clone schemaRegistry with overridden options
+     */
+    clone: (options?: Omit<Options, 'schemas'>, onSchema?: (schema: JSONSchema7Object) => JSONSchema7Object) => SchemaForgeRegistry;
+    /**
+     * Remove all schemas from registry
+     */
+    clear: VoidFunction;
+    /**
+     * Add root schema's to registry
+     */
+    addSchema: (schema: JSONSchema7Object[]) => void;
+    /**
+     * Check if schema (or definition) is already registered
+     */
+    hasSchema: (ref: SchemaForgeDefinitionRef) => boolean;
+    /**
+     * Remove schema (or definition) from registry
+     */
+    removeSchema: (ref: ArrayMay<SchemaForgeDefinitionRef>) => void;
+    /**
+     * Get schema (or definition) object
+     */
+    getSchema: (ref: SchemaForgeDefinitionRef) => JSONSchema7 | undefined;
+    /**
+     * Get schema (or definition) validation function
+     */
+    getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | JSONSchema7) => SchemaForgeValidationFunction<TData> | undefined;
+    /**
+     * Get root schema object
+     */
+    getRootSchema: (schemaId: string) => JSONSchema7 | undefined;
+    /**
+     * Validate data by schema definition reference
+     */
+    validateBySchema: (ref: SchemaForgeDefinitionRef, data: unknown, instancePath?: string) => SchemaForgeValidationResult;
+    /**
+     * Check (throw error if invalid) data by schema definition reference
+     */
+    checkBySchema: <T = unknown, Ctx extends SchemaForgeValidationContextBase = SchemaForgeValidationContextBase>(ref: SchemaForgeDefinitionRef, data: T, context?: Ctx) => data is T;
+    /**
+     * Get validation errors text
+     */
+    validationErrorsText: (errors: Nullable<SchemaForgeValidationReport>, options?: ErrorsTextOptions) => string;
+    /**
+     * List schema definitions
+     */
+    listDefinitions: (predicate?: SchemaForgeRegistryListDefinitionsPredicate) => SchemaDefinitionInfo[];
+    /**
+     * Asynchronously warm up schemaRegistry cache.
+     * This action is useful to pre-compile all schemas and their definitions
+     */
+    warmupCache: (schemasPerIteration?: number, delayMs?: number) => Promise<void>;
+    /**
+     * Synchronously warm up schemaRegistry cache.
+     * This action is useful to pre-compile all schemas and their definitions
+     */
+    warmupCacheSync: VoidFunction;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/schema-registry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema-registry/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,KAAK,EACR,wBAAwB,EACxB,6BAA6B,EAC7B,2BAA2B,EAC3B,2BAA2B,EAC9B,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,2CAA2C,GAAG,CACtD,IAAI,EAAE,oBAAoB,EAC1B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,KACpB,OAAO,CAAC;AAEb,MAAM,WAAW,mBAAmB;IAChC;;OAEG;IACH,QAAQ,CAAC,wBAAwB,EAAE,cAAc,CAAC;IAElD;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAE7B;;OAEG;IACH,KAAK,EAAE,CACH,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EAClC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,iBAAiB,KAC1D,mBAAmB,CAAC;IAEzB;;OAEG;IACH,KAAK,EAAE,YAAY,CAAC;IAEpB;;OAEG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IAEjD;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,EAAE,wBAAwB,KAAK,OAAO,CAAC;IAEtD;;OAEG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,wBAAwB,CAAC,KAAK,IAAI,CAAC;IAEhE;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,EAAE,wBAAwB,KAAK,WAAW,GAAG,SAAS,CAAC;IAEtE;;OAEG;IACH,YAAY,EAAE,CAAC,KAAK,GAAG,OAAO,EAC1B,GAAG,EAAE,wBAAwB,GAAG,WAAW,KAC1C,6BAA6B,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAEtD;;OAEG;IACH,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;IAE7D;;OAEG;IACH,gBAAgB,EAAE,CACd,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,OAAO,EACb,YAAY,CAAC,EAAE,MAAM,KACpB,2BAA2B,CAAC;IAEjC;;OAEG;IACH,aAAa,EAAE,CACX,CAAC,GAAG,OAAO,EACX,GAAG,SAAS,gCAAgC,GAAG,gCAAgC,EAE/E,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,GAAG,KACZ,IAAI,IAAI,CAAC,CAAC;IAEf;;OAEG;IACH,oBAAoB,EAAE,CAClB,MAAM,EAAE,QAAQ,CAAC,2BAA2B,CAAC,EAC7C,OAAO,CAAC,EAAE,iBAAiB,KAC1B,MAAM,CAAC;IAEZ;;OAEG;IACH,eAAe,EAAE,CACb,SAAS,CAAC,EAAE,2CAA2C,KACtD,oBAAoB,EAAE,CAAC;IAE5B;;;OAGG;IACH,WAAW,EAAE,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/E;;;OAGG;IACH,eAAe,EAAE,YAAY,CAAC;CACjC"}

package/lib/schema-registry/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });