@tsofist/schema-forge 2.0.0 → 2.2.0

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

@@ -11,7 +11,7 @@ interface Options {
     definitions: string[];
     schemaId?: string;
     expose?: TypeExposeKind;
-    openAPI?: boolean;
+    openapiCompatible?: boolean;
     sortObjectProperties?: boolean;
     allowUseFallbackDescription?: boolean;
 }

package/lib/generator/schema-generator.js

@@ -26,10 +26,13 @@ async function generateSchemaByDraftTypes(options) {
         expose: options.expose ?? types_1.SG_CONFIG_DEFAULTS.expose,
         path: `${options.sourcesDirectoryPattern}/*${types_1.TMP_FILES_SUFFIX}.ts`,
         tsconfig: options.tsconfig,
-        discriminatorType: options.openAPI ? 'open-api' : ts_json_schema_generator_1.DEFAULT_CONFIG.discriminatorType,
+        discriminatorType: options.openapiCompatible
+            ? 'open-api'
+            : ts_json_schema_generator_1.DEFAULT_CONFIG.discriminatorType,
         ...types_1.SG_CONFIG_MANDATORY,
     };
     const generatorProgram = (0, ts_json_schema_generator_1.createProgram)(generatorConfig);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const typeChecker = generatorProgram.getTypeChecker();
     const parser = (0, ts_json_schema_generator_1.createParser)(generatorProgram, options.sourcesTypesGeneratorConfig, (parser) => {
         parser.addNodeParser(new TupleTypeParser(parser, allowUseFallbackDescription));
@@ -41,6 +44,10 @@ async function generateSchemaByDraftTypes(options) {
         $schema: 'http://json-schema.org/draft-07/schema#',
         $id: options.schemaId,
         hash: '',
+        title: undefined,
+        description: undefined,
+        version: undefined,
+        $comment: undefined,
         definitions: {},
     };
     for (const definitionName of options.definitions) {

package/lib/generator.js

@@ -10,10 +10,10 @@ const promises_2 = require("node:fs/promises");
 const as_array_1 = require("@tsofist/stem/lib/as-array");
 const error_1 = require("@tsofist/stem/lib/error");
 const noop_1 = require("@tsofist/stem/lib/noop");
-const keys_1 = require("@tsofist/stem/lib/object/keys");
 const random_1 = require("@tsofist/stem/lib/string/random");
 const schema_generator_1 = require("./generator/schema-generator");
 const types_generator_1 = require("./generator/types-generator");
+const index_1 = require("./index");
 const KEEP_ARTEFACTS = false;
 async function forgeSchema(options) {
     const { schemaId, sourcesDirectoryPattern, outputSchemaFile } = options;
@@ -37,33 +37,30 @@ async function forgeSchema(options) {
             tsconfig,
             sourcesPattern,
         });
-        const refs = definitions.map((item) => `${options.schemaId || ''}#/definitions/${item}`);
+        const refs = definitions.map((item) => (0, index_1.buildSchemaDefinitionRef)(item, options.schemaId));
         let schema;
         try {
             {
-                schema = await (0, schema_generator_1.generateSchemaByDraftTypes)({
-                    schemaId,
-                    tsconfig,
-                    definitions,
-                    sourcesDirectoryPattern,
-                    outputSchemaFile,
-                    sourcesTypesGeneratorConfig,
-                    expose: options.expose,
-                    openAPI: options.openapiCompatible,
-                    sortObjectProperties: options.sortObjectProperties,
-                    allowUseFallbackDescription: options.allowUseFallbackDescription,
-                });
-                if (options.schemaMetadata) {
-                    for (const key of (0, keys_1.keysOf)(options.schemaMetadata)) {
-                        schema[key] = options.schemaMetadata[key];
-                    }
-                }
+                schema = {
+                    ...(await (0, schema_generator_1.generateSchemaByDraftTypes)({
+                        schemaId,
+                        tsconfig,
+                        definitions,
+                        sourcesDirectoryPattern,
+                        outputSchemaFile,
+                        sourcesTypesGeneratorConfig,
+                        expose: options.expose,
+                        openapiCompatible: options.openapiCompatible,
+                        sortObjectProperties: options.sortObjectProperties,
+                        allowUseFallbackDescription: options.allowUseFallbackDescription,
+                    })),
+                    ...(options.schemaMetadata || {}),
+                };
                 {
-                    const algorithm = options.schemaMetadata?.hash == null
+                    const algorithm = options.schemaMetadata?.hash == null ||
+                        options.schemaMetadata?.hash === true
                         ? 'md5'
-                        : options.schemaMetadata?.hash === true
-                            ? 'md5'
-                            : options.schemaMetadata.hash;
+                        : options.schemaMetadata.hash;
                     if (algorithm) {
                         schema.hash = (0, node_crypto_1.createHash)(algorithm, {})
                             .update(JSON.stringify(schema))
@@ -79,11 +76,11 @@ async function forgeSchema(options) {
             if (options.outputSchemaMetadataFile) {
                 const map = {
                     $id: options.schemaId || '',
-                    version: options.schemaMetadata?.version,
+                    schemaHash: schema.hash,
                     title: options.schemaMetadata?.title,
                     description: options.schemaMetadata?.description,
+                    version: options.schemaMetadata?.version,
                     $comment: options.schemaMetadata?.$comment,
-                    schemaHash: schema.hash,
                     refs: {},
                     names: {},
                     serviceRefs: {},
@@ -91,14 +88,15 @@ async function forgeSchema(options) {
                 };
                 const defs = new Set(Object.keys((schema.definitions || {})));
                 for (const name of definitions) {
-                    const ref = `${options.schemaId || ''}#/definitions/${name}`;
+                    const ref = (0, index_1.buildSchemaDefinitionRef)(name, schemaId);
                     map.names[name] = ref;
                     map.refs[ref] = name;
                     defs.delete(name);
                 }
                 for (const name of defs) {
-                    map.serviceNames[name] = `${options.schemaId || ''}#/definitions/${name}`;
-                    map.serviceRefs[`${options.schemaId || ''}#/definitions/${name}`] = name;
+                    const ref = (0, index_1.buildSchemaDefinitionRef)(name, options.schemaId);
+                    map.serviceNames[name] = ref;
+                    map.serviceRefs[ref] = name;
                 }
                 const content = JSON.stringify(map, null, 2);
                 await (0, promises_1.writeFile)(options.outputSchemaMetadataFile, content, {

package/lib/generator.spec.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("node:fs/promises");
 const error_1 = require("@tsofist/stem/lib/error");
 const noop_1 = require("@tsofist/stem/lib/noop");
+const pick_1 = require("@tsofist/stem/lib/object/pick");
 const generator_1 = require("./generator");
 const types_1 = require("./types");
 const validator_1 = require("./validator");
@@ -12,8 +13,14 @@ const KEEP_ARTEFACTS = false;
 describe('generator for a7', () => {
     const outputSchemaFile = './a7.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a7.generated.definitions.tmp.json';
+    const schemaMetadata = {
+        title: 'Generator TEST',
+        version: '1.0.0',
+        $comment: 'WARN: This is a test schema.',
+    };
     let forgeSchemaResult;
     let validator;
+    let loadedSchema;
     beforeAll(async () => {
         forgeSchemaResult = await (0, generator_1.forgeSchema)({
             schemaId: 'test',
@@ -25,10 +32,11 @@ describe('generator for a7', () => {
             outputSchemaMetadataFile,
             expose: 'all',
             explicitPublic: true,
+            schemaMetadata,
         });
         validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        const schema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
-        validator.addSchema(schema);
+        loadedSchema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
+        validator.addSchema(loadedSchema);
     });
     afterAll(async () => {
         if (!KEEP_ARTEFACTS) {
@@ -36,6 +44,11 @@ describe('generator for a7', () => {
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
     });
+    it('generated schema should have correct metadata', () => {
+        expect(forgeSchemaResult).toBeTruthy();
+        const schema = forgeSchemaResult.schema;
+        expect((0, pick_1.pickProps)(schema, Object.keys(schemaMetadata))).toStrictEqual(schemaMetadata);
+    });
     it('generated schema should be valid', () => {
         expect(forgeSchemaResult).toBeTruthy();
         const schema = validator.getSchema('test#/definitions/SomeAPI_doSomeWithUser_Args');
@@ -50,6 +63,48 @@ describe('generator for a7', () => {
         expect(schema.maxItems).toStrictEqual(3);
     });
 });
+describe('validator for a7', () => {
+    const outputSchemaFile = './a7.generated.schema.tmp.json';
+    const outputSchemaMetadataFile = './a7.generated.definitions.tmp.json';
+    let validator;
+    let loadedSchema;
+    beforeAll(async () => {
+        await (0, generator_1.forgeSchema)({
+            schemaId: 'test',
+            allowUseFallbackDescription: true,
+            tsconfigFrom: './tsconfig.build-test.json',
+            sourcesDirectoryPattern: 'test-sources/a7',
+            sourcesFilesPattern: ['service-api.ts', 'types.ts'],
+            outputSchemaFile,
+            outputSchemaMetadataFile,
+            expose: 'all',
+            explicitPublic: true,
+        });
+        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
+        loadedSchema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
+        validator.addSchema(loadedSchema);
+    });
+    afterAll(async () => {
+        if (!KEEP_ARTEFACTS) {
+            await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
+            await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
+        }
+    });
+    it('should be able to warm-up cache', async () => {
+        const initial = validator.compilationArtifactCount;
+        expect(initial).toStrictEqual(2);
+        validator.warmupCacheSync();
+        const warmed = validator.compilationArtifactCount;
+        expect(warmed).toStrictEqual(10);
+        validator.clear();
+        const cleared = validator.compilationArtifactCount;
+        expect(cleared).toStrictEqual(1);
+        validator.addSchema(loadedSchema);
+        expect(validator.compilationArtifactCount).toStrictEqual(initial);
+        await validator.warmupCache();
+        expect(validator.compilationArtifactCount).toStrictEqual(warmed);
+    });
+});
 describe('generator for a6', () => {
     const outputSchemaFile = './a6.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a6.generated.definitions.tmp.json';

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import '@total-typescript/ts-reset';
-import { SchemaDefinitionInfo, SchemaForgeSignatureSuffix } from './types';
+import { SchemaDefinitionInfo, SchemaForgeDefinitionRef, SchemaForgeSignatureSuffix } from './types';
 export declare function buildAPIInterfaceSchemaSignature(interfaceName: string): string;
 export declare function buildAPIInterfaceSchemaSignature(interfaceName: string, memberName: string): string;
 export declare function buildAPIInterfaceSchemaSignature(interfaceName: string, methodName: string, suffix: SchemaForgeSignatureSuffix): string;
+export declare function buildSchemaDefinitionRef(definitionName: string, schemaId: string | undefined): SchemaForgeDefinitionRef;
 export declare function parseSchemaDefinitionInfo(name: string, schemaId: string): SchemaDefinitionInfo;

package/lib/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildAPIInterfaceSchemaSignature = buildAPIInterfaceSchemaSignature;
+exports.buildSchemaDefinitionRef = buildSchemaDefinitionRef;
 exports.parseSchemaDefinitionInfo = parseSchemaDefinitionInfo;
 require("@total-typescript/ts-reset");
 const substr_1 = require("@tsofist/stem/lib/string/substr");
@@ -20,6 +21,9 @@ function buildAPIInterfaceSchemaSignature(interfaceName, memberName, suffix) {
     }
     return result;
 }
+function buildSchemaDefinitionRef(definitionName, schemaId) {
+    return `${schemaId || ''}#/definitions/${definitionName}`;
+}
 function parseSchemaDefinitionInfo(name, schemaId) {
     const kind = name.endsWith(N_I)
         ? types_1.SchemaDefinitionKind.API
@@ -28,7 +32,7 @@ function parseSchemaDefinitionInfo(name, schemaId) {
             : name.endsWith(N_R)
                 ? types_1.SchemaDefinitionKind.APIMethodResult
                 : types_1.SchemaDefinitionKind.Type;
-    const ref = `${schemaId}#/definitions/${name}`;
+    const ref = buildSchemaDefinitionRef(name, schemaId);
     switch (kind) {
         case types_1.SchemaDefinitionKind.API:
             return {

package/lib/validator.d.ts

@@ -1,35 +1,47 @@
-import { Nullable } from '@tsofist/stem';
-import { AnySchema, ErrorsTextOptions, Options, Schema, SchemaObject } from 'ajv';
+import { ArrayMay, Nullable } from '@tsofist/stem';
+import { ErrorsTextOptions, Options, SchemaObject } from 'ajv';
 import { SchemaDefinitionInfo, SchemaForgeDefinitionRef, SchemaForgeValidationContextBase, SchemaForgeValidationFunction, SchemaForgeValidationReport, SchemaForgeValidationResult } from './types';
 export type SchemaForgeValidator = ReturnType<typeof createSchemaForgeValidator>;
+export type SchemaForgeValidatorOptions = Parameters<typeof createSchemaForgeValidator>;
+/**
+ * Create SchemaForge Registry: a json-schema validator with additional features
+ */
 export declare function createSchemaForgeValidator(engineOptions?: Options, useAdditionalFormats?: boolean): {
+    readonly compilationArtifactCount: number;
     readonly rev: number;
+    clear: () => void;
     clone: (options?: Omit<Options, "schemas">, onSchema?: (value: SchemaObject) => SchemaObject) => {
+        readonly compilationArtifactCount: number;
         readonly rev: number;
+        clear: () => void;
         clone: /*elided*/ any;
-        removeSchema: (schemaIdentity?: AnySchema | SchemaForgeDefinitionRef | RegExp) => void;
+        removeSchema: (ref: ArrayMay<SchemaForgeDefinitionRef>) => void;
         hasValidator: (ref: SchemaForgeDefinitionRef) => boolean;
-        getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | AnySchema) => SchemaForgeValidationFunction<TData> | undefined;
-        getSchema: (ref: SchemaForgeDefinitionRef) => AnySchema | undefined;
+        getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | SchemaObject) => SchemaForgeValidationFunction<TData> | undefined;
+        getSchema: (ref: SchemaForgeDefinitionRef) => import("ajv").AnySchema | undefined;
         getRootSchema: (schemaId: string) => (SchemaObject & {
-            definitions?: AnySchema;
+            definitions?: SchemaObject;
         }) | undefined;
-        addSchema: (schema: Schema[]) => void;
+        addSchema: (schema: SchemaObject[]) => void;
         validateBySchema: (ref: SchemaForgeDefinitionRef, data: unknown, instancePath?: string) => SchemaForgeValidationResult;
         checkBySchema: <T = unknown, Ctx extends SchemaForgeValidationContextBase = SchemaForgeValidationContextBase>(ref: SchemaForgeDefinitionRef, data: unknown, context?: Ctx) => data is T;
         validationErrorsText: (errors: Nullable<SchemaForgeValidationReport>, options?: ErrorsTextOptions) => string;
         listDefinitions: (predicate?: (info: SchemaDefinitionInfo) => boolean) => SchemaDefinitionInfo[];
+        warmupCache: (schemasPerIteration?: number, delayMs?: number) => Promise<void>;
+        warmupCacheSync: () => void;
     };
-    removeSchema: (schemaIdentity?: AnySchema | SchemaForgeDefinitionRef | RegExp) => void;
+    removeSchema: (ref: ArrayMay<SchemaForgeDefinitionRef>) => void;
     hasValidator: (ref: SchemaForgeDefinitionRef) => boolean;
-    getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | AnySchema) => SchemaForgeValidationFunction<TData> | undefined;
-    getSchema: (ref: SchemaForgeDefinitionRef) => AnySchema | undefined;
+    getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | SchemaObject) => SchemaForgeValidationFunction<TData> | undefined;
+    getSchema: (ref: SchemaForgeDefinitionRef) => import("ajv").AnySchema | undefined;
     getRootSchema: (schemaId: string) => (SchemaObject & {
-        definitions?: AnySchema;
+        definitions?: SchemaObject;
     }) | undefined;
-    addSchema: (schema: Schema[]) => void;
+    addSchema: (schema: SchemaObject[]) => void;
     validateBySchema: (ref: SchemaForgeDefinitionRef, data: unknown, instancePath?: string) => SchemaForgeValidationResult;
     checkBySchema: <T = unknown, Ctx extends SchemaForgeValidationContextBase = SchemaForgeValidationContextBase>(ref: SchemaForgeDefinitionRef, data: unknown, context?: Ctx) => data is T;
     validationErrorsText: (errors: Nullable<SchemaForgeValidationReport>, options?: ErrorsTextOptions) => string;
     listDefinitions: (predicate?: (info: SchemaDefinitionInfo) => boolean) => SchemaDefinitionInfo[];
+    warmupCache: (schemasPerIteration?: number, delayMs?: number) => Promise<void>;
+    warmupCacheSync: () => void;
 };

package/lib/validator.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSchemaForgeValidator = createSchemaForgeValidator;
+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 types_1 = require("./types");
 const index_1 = require("./index");
 const DEF_OPTIONS = {
+    meta: true,
+    defaultMeta: 'http://json-schema.org/draft-07/schema',
     allErrors: true,
     strict: true,
     strictSchema: true,
@@ -18,14 +23,33 @@ const DEF_OPTIONS = {
     coerceTypes: false,
     removeAdditional: false,
     unicodeRegExp: true,
+    useDefaults: false,
+    addUsedSchema: false,
+    inlineRefs: true,
+    ownProperties: true,
+    discriminator: false,
+    code: {
+        es5: false,
+        esm: false,
+        optimize: 2,
+    },
 };
+/**
+ * Create SchemaForge Registry: a json-schema validator with additional features
+ */
 function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false) {
     engineOptions = {
         ...DEF_OPTIONS,
         ...engineOptions,
     };
+    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);
@@ -37,7 +61,10 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
         for (const env of (0, values_1.nonNullableValues)(engine.schemas)) {
             if (env.meta)
                 continue;
-            schemas.push(onSchema ? onSchema(env.schema) : env.schema);
+            const schema = onSchema
+                ? onSchema(env.schema)
+                : env.schema;
+            schemas.push(schema);
         }
         const opts = {
             ...engineOptions,
@@ -52,13 +79,16 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
     function getValidator(ref) {
         if (typeof ref === 'string')
             return engine.getSchema(ref);
-        return engine.compile(ref);
+        const result = engine.compile(ref);
+        checkIsSyncValidator(result);
+        return result;
     }
     /**
      * Check if schema exists
+     * WARN: this method may compile schema if it's not compiled yet
      */
     function hasValidator(ref) {
-        return engine.getSchema(ref) != null;
+        return ref in engine.schemas || ref in engine.refs || engine.getSchema(ref) != null;
     }
     /**
      * Add root schema(s) to registry
@@ -68,10 +98,18 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
         rev++;
     }
     /**
-     * Remove root schema(s) from registry using Schema object, Reference or RegExp pattern to math Schema ID
+     * Remove root schema(s) from registry
+     */
+    function removeSchema(ref) {
+        for (const item of (0, as_array_1.asArray)(ref))
+            engine.removeSchema(item);
+        rev++;
+    }
+    /**
+     * Remove all schemas from registry
      */
-    function removeSchema(schemaIdentity) {
-        engine.removeSchema(schemaIdentity);
+    function clear() {
+        engine.removeSchema();
         rev++;
     }
     /**
@@ -119,7 +157,8 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
         }
         return result.valid;
     }
-    function forEachDefinitions(callback) {
+    function mapDefinitions(callback) {
+        const result = [];
         for (const [schemaId, env] of (0, entries_1.entries)(engine.schemas)) {
             if (env &&
                 typeof env.schema === 'object' &&
@@ -127,17 +166,18 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
                 env.schema.definitions &&
                 typeof env.schema.definitions === 'object') {
                 for (const name of Object.keys(env.schema.definitions)) {
-                    callback(name, schemaId);
+                    result.push(callback(name, schemaId));
                 }
             }
         }
+        return result;
     }
     /**
      * List schema definitions
      */
     function listDefinitions(predicate) {
         const result = [];
-        forEachDefinitions((name, schemaId) => {
+        mapDefinitions((name, schemaId) => {
             const info = (0, index_1.parseSchemaDefinitionInfo)(name, schemaId);
             if (predicate === undefined || predicate(info))
                 result.push(info);
@@ -156,10 +196,40 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
     function getRootSchema(schemaId) {
         return engine.schemas[schemaId]?.schema;
     }
+    /**
+     * Synchronously warm up validator cache
+     * This action is useful to pre-compile all schemas and their definitions
+     */
+    function warmupCacheSync() {
+        mapDefinitions((name, schemaId) => {
+            const ref = (0, index_1.buildSchemaDefinitionRef)(name, schemaId);
+            checkIsSyncValidator(engine.getSchema(ref));
+        });
+    }
+    /**
+     * Asynchronously warm up validator cache
+     * This action is useful to pre-compile all schemas and their definitions
+     */
+    async function warmupCache(schemasPerIteration = 5, delayMs = 1) {
+        await (0, chunk_1.chunk)(mapDefinitions((name, schemaId) => (0, index_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,
         removeSchema,
         hasValidator,
@@ -171,6 +241,8 @@ function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false)
         checkBySchema,
         validationErrorsText,
         listDefinitions,
+        warmupCache,
+        warmupCacheSync,
     };
 }
 function addJSDocKeywords(engine) {
@@ -181,6 +253,13 @@ function addJSDocKeywords(engine) {
     const IXNamePattern = '^ix_[a-z][a-zA-Z0-9_]+$';
     const EntityNamePattern = '^([a-zA-Z_][a-z0-9_]*\\.)?[a-z_][a-z0-9_]*$';
     const FakerModulePattern = '^[a-zA-Z.]+$';
+    engine.addKeyword({
+        keyword: 'version',
+        metaSchema: {
+            type: 'string',
+        },
+        dependencies: ['$id', '$schema'],
+    });
     engine.addKeyword({
         keyword: 'hash',
         metaSchema: {
@@ -265,3 +344,8 @@ function addJSDocKeywords(engine) {
         },
     });
 }
+function checkIsSyncValidator(fn) {
+    if (typeof fn === 'function' && '$async' in fn) {
+        (0, error_1.raise)('[SchemaForge] Asynchronous validation schemas are not supported');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsofist/schema-forge",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Generate JSON schema from TypeScript types",
   "author": "Andrew Berdnikov <tsofistgudmen@gmail.com>",
   "license": "LGPL-3.0",
@@ -20,8 +20,8 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@faker-js/faker": "^9.4.0",
-    "@tsofist/stem": "^2.0.0",
+    "@faker-js/faker": "^9.6.0",
+    "@tsofist/stem": "^2.2.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "json-schema-faker": "^0.5.8",
@@ -31,13 +31,13 @@
   "devDependencies": {
     "@tsofist/web-buddy": "^1.21.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.17.17",
-    "@types/supertest": "^6.0.2",
+    "@types/node": "^20.17.28",
+    "@types/supertest": "^6.0.3",
     "jest": "^29.7.0",
     "rimraf": "^6.0.1",
-    "supertest": "^7.0.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "~5.7.3"
+    "supertest": "^7.1.0",
+    "ts-jest": "^29.3.0",
+    "typescript": "~5.8.2"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",