@tsofist/schema-forge 2.12.0 → 3.0.0-next.1

package/lib/{fake-generator.spec.js → fake-generator/generator.spec.js}

@@ -6,8 +6,8 @@ const enum_1 = require("@tsofist/stem/lib/enum");
 const guards_2 = require("@tsofist/stem/lib/number/integer/guards");
 const entries_1 = require("@tsofist/stem/lib/object/entries");
 const camel_1 = require("@tsofist/stem/lib/string/case/camel");
-const fake_generator_1 = require("./fake-generator");
-const validator_1 = require("./validator");
+const registry_1 = require("../schema-registry/registry");
+const generator_1 = require("./generator");
 /* eslint-disable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 describe('generateFakeData', () => {
     const testSchema1 = {
@@ -180,58 +180,60 @@ describe('generateFakeData', () => {
             };
         }
     }
-    let validator;
+    let registry;
     beforeEach(() => {
-        validator = (0, validator_1.createSchemaForgeValidator)({ schemas: [testSchema1, testSchema2, testSchema3, testSchema4] }, true);
+        registry = (0, registry_1.createSchemaForgeRegistry)({
+            engine: { schemas: [testSchema1, testSchema2, testSchema3, testSchema4] },
+        });
     });
     it('default behavior', async () => {
         {
-            const data = await (0, fake_generator_1.generateFakeData)(validator, 'test-1#/definitions/Int');
+            const data = await (0, generator_1.generateFakeData)(registry, 'test-1#/definitions/Int');
             expect(data).toBeDefined();
             expect(data).toBeGreaterThanOrEqual(0);
             expect((0, guards_2.isInt)(data)).toStrictEqual(true);
         }
         {
-            const data = await (0, fake_generator_1.generateFakeData)(validator, 'test-2#/definitions/Url');
+            const data = await (0, generator_1.generateFakeData)(registry, 'test-2#/definitions/Url');
             expect(data).toBeDefined();
             expect(data).toMatch(/^https?:\/\/(.*)/);
         }
     });
     it('cross-schema references should be handled correctly', async () => {
         const source = 'test-2#/definitions/ForeignInt';
-        const data = await (0, fake_generator_1.generateFakeData)(validator, source);
+        const data = await (0, generator_1.generateFakeData)(registry, source);
         expect(data).toBeDefined();
         expect(data).toBeGreaterThanOrEqual(0);
         expect((0, guards_2.isInt)(data)).toStrictEqual(true);
-        expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+        expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
     });
     it('complex, nested data should be handled correctly', async () => {
         {
             const source = 'test-2#/definitions/JSFQuirks';
-            const data = await (0, fake_generator_1.generateFakeData)(validator, source, {});
+            const data = await (0, generator_1.generateFakeData)(registry, source, {});
             expect(data).toBeDefined();
-            expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+            expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
         }
         {
             const source = 'test-2#/definitions/List';
-            const data = await (0, fake_generator_1.generateFakeData)(validator, source);
+            const data = await (0, generator_1.generateFakeData)(registry, source);
             expect(data).toBeDefined();
-            expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+            expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
         }
         {
             const source = 'test-2#/definitions/ListOfNames';
             const len = 15;
-            const data = await (0, fake_generator_1.generateFakeData)(validator, source, { minItems: len, locale: 'ru' });
+            const data = await (0, generator_1.generateFakeData)(registry, source, { minItems: len, locale: 'ru' });
             expect(data).toBeDefined();
-            expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+            expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
             expect(Array.isArray(data)).toStrictEqual(true);
             expect(data.length).toBeGreaterThanOrEqual(len);
             expect(data.join(' ')).toMatch(/[=^+U+0400–U+04FF\s\S@/_-]+/);
         }
         {
             const source = 'test-2#/definitions/Entity';
-            const data = await (0, fake_generator_1.generateFakeData)(validator, source, { locale: 'ru' });
-            expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+            const data = await (0, generator_1.generateFakeData)(registry, source, { locale: 'ru' });
+            expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
             expect(typeof data.datetime).toStrictEqual('string');
             expect(data.datetime).toMatch(/.*Z$/);
             expect(new Date(data.datetime)).not.toStrictEqual('Invalid Date');
@@ -243,7 +245,7 @@ describe('generateFakeData', () => {
         const source = 'test-3#/definitions/RecursiveObject';
         const count = 10;
         for (let i = 0; i < count; i++) {
-            const data = await (0, fake_generator_1.generateFakeData)(validator, source, {
+            const data = await (0, generator_1.generateFakeData)(registry, source, {
                 reuseProperties: false,
                 failOnInvalidFormat: true,
                 failOnInvalidTypes: true,
@@ -255,11 +257,11 @@ describe('generateFakeData', () => {
                 refDepthMax: 20,
             });
             expect(data).toBeDefined();
-            expect(validator.validateBySchema(source, data).valid).toStrictEqual(true);
+            expect(registry.validateBySchema(source, data).valid).toStrictEqual(true);
         }
     });
     it('should handle CLDR formats', async () => {
-        const data = await (0, fake_generator_1.generateFakeData)(validator, 'test-4#/definitions/CLDR');
+        const data = await (0, generator_1.generateFakeData)(registry, 'test-4#/definitions/CLDR');
         const guards = {
             [types_1.ISODateTimeType.LocalDate]: guards_1.isLocalISODateString,
             [types_1.ISODateTimeType.LocalTime]: guards_1.isLocalISOTimeString,

package/lib/fake-generator/modules.d.ts

@@ -0,0 +1,3 @@
+import type { SetupFakerModules } from './types';
+export declare const EmbeddedFakerModules: SetupFakerModules[];
+//# sourceMappingURL=modules.d.ts.map

package/lib/fake-generator/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../src/fake-generator/modules.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAiB,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,EA0CnD,CAAC"}

package/lib/fake-generator/modules.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedFakerModules = void 0;
+const native_date_1 = require("@tsofist/stem/lib/cldr/date-time/native-date");
+const types_1 = require("@tsofist/stem/lib/cldr/date-time/types");
+exports.EmbeddedFakerModules = [
+    (faker) => ({
+        sf: {
+            /** FakerModule: sf.url */
+            url(origin = 'https://example.com', paths = { min: 1, max: 5 }, pathWords = { min: 1, max: 3 }) {
+                const pathParts = new Array(faker.helpers.rangeToNumber(paths))
+                    .fill('')
+                    .map(() => faker.lorem.slug(pathWords));
+                return `${origin}/${pathParts.join('/')}`;
+            },
+        },
+        cldr: {
+            /** FakerModule: cldr.localDateTime */
+            localDateTime() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.LocalDateTime, true);
+            },
+            /** FakerModule: cldr.localDate */
+            localDate() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.LocalDate);
+            },
+            /** FakerModule: cldr.localTime */
+            localTime() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.LocalTime, true);
+            },
+            /** FakerModule: cldr.zuluDateTime */
+            zuluDateTime() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.ZuluDateTime);
+            },
+            /** FakerModule: cldr.zuluDate */
+            zuluDate() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.ZuluDate);
+            },
+            /** FakerModule: cldr.zuluTime */
+            zuluTime() {
+                return (0, native_date_1.dateToTypedString)(new Date(), types_1.ISODateTimeType.ZuluTime);
+            },
+        },
+    }),
+];

package/lib/fake-generator/types.d.ts

@@ -0,0 +1,18 @@
+import * as fakerModule from '@faker-js/faker';
+import type { ArrayMay } from '@tsofist/stem';
+import { JSONSchemaFaker, type JSONSchemaFakerOptions } from 'json-schema-faker';
+import type { SchemaForgeRegistry } from '../schema-registry/types';
+export type SetupFakerModules = (faker: fakerModule.Faker) => object;
+export type FakerRangeNum = Parameters<fakerModule.HelpersModule['rangeToNumber']>[0];
+export type FakeGeneratorLocaleName = keyof typeof fakerModule.allLocales;
+export interface FakeGeneratorOptions extends JSONSchemaFakerOptions {
+    locale?: ArrayMay<FakeGeneratorLocaleName>;
+    setupFakerModules?: SetupFakerModules[];
+}
+export interface FakeGeneratorHost {
+    readonly schemaRegistry: SchemaForgeRegistry;
+    readonly faker: fakerModule.Faker;
+    readonly generator: typeof JSONSchemaFaker;
+    readonly rebuild: () => this;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/fake-generator/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/fake-generator/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,KAAK,MAAM,CAAC;AACrE,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtF,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,WAAW,CAAC,UAAU,CAAC;AAC1E,MAAM,WAAW,oBAAqB,SAAQ,sBAAsB;IAChE,MAAM,CAAC,EAAE,QAAQ,CAAC,uBAAuB,CAAC,CAAC;IAC3C,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,OAAO,eAAe,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAChC"}

package/lib/fake-generator/types.js

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

package/lib/schema-generator/extended-annotations-reader.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extended-annotations-reader.d.ts.map

package/lib/schema-generator/extended-annotations-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extended-annotations-reader.d.ts","sourceRoot":"","sources":["../../src/schema-generator/extended-annotations-reader.ts"],"names":[],"mappings":""}

package/lib/{util/patch.extended-annotations-reader.js → schema-generator/extended-annotations-reader.js}

@@ -4,13 +4,13 @@ const error_1 = require("@tsofist/stem/lib/error");
 const is_empty_1 = require("@tsofist/stem/lib/object/is-empty");
 const ts_json_schema_generator_1 = require("ts-json-schema-generator");
 const typescript_1 = require("typescript");
-const tsc_1 = require("./tsc");
+const helpers_tsc_1 = require("./helpers-tsc");
 {
     // Support for @inheritDoc tag to enforce inheritance of annotations
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const getAnnotations = ts_json_schema_generator_1.ExtendedAnnotationsReader.prototype.getAnnotations;
     ts_json_schema_generator_1.ExtendedAnnotationsReader.prototype.getAnnotations = function getAnnotationsWithInheritance(node) {
-        if (!(0, tsc_1.hasJSDocTag)(node, 'inheritDoc'))
+        if (!(0, helpers_tsc_1.hasJSDocTag)(node, 'inheritDoc'))
             return getAnnotations.call(this, node);
         // @ts-expect-error access to private property
         const checker = this.typeChecker || (0, error_1.raise)('TypeChecker is not available');

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

@@ -0,0 +1,3 @@
+import type { ForgeSchemaResult, ForgeSchemaOptions } from '../types';
+export declare function forgeSchema(options: ForgeSchemaOptions): Promise<ForgeSchemaResult>;
+//# sourceMappingURL=forge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forge.d.ts","sourceRoot":"","sources":["../../src/schema-generator/forge.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAuB,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAI3F,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAsHzF"}

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

@@ -1,58 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forgeSchema = forgeSchema;
-exports.loadJSONSchema = loadJSONSchema;
-exports.loadJSONSchemaSync = loadJSONSchemaSync;
 const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
 const promises_1 = 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 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;
+const artefacts_policy_1 = require("../artefacts-policy");
+const ref_1 = require("../definition-info/ref");
+const generate_drafts_1 = require("./generate-drafts");
+const generate_schema_1 = require("./generate-schema");
 async function forgeSchema(options) {
-    const { schemaId, sourcesDirectoryPattern, outputSchemaFile } = options;
-    const sourcesPattern = (0, as_array_1.asArray)(options.sourcesFilesPattern).map((filesPattern) => `${sourcesDirectoryPattern}/${filesPattern}`);
+    const sourcesPattern = (0, as_array_1.asArray)(options.sourcesFilesPattern).map((filesPattern) => `${options.sourcesDirectoryPattern}/${filesPattern}`);
     let tsconfig = options.tsconfig;
     let tsconfigGenerated = false;
     try {
         if (options.tsconfigFrom) {
-            tsconfigGenerated = true;
             const source = await (0, promises_1.readFile)(options.tsconfigFrom, { encoding: 'utf8' });
             const config = JSON.parse(source);
             config.include = sourcesPattern;
             config.compilerOptions.noUnusedLocals = false;
             tsconfig = `./tsconfig.schema-forge-generated.${(0, random_1.randomString)(5)}.tmp.json`;
             await (0, promises_1.writeFile)(tsconfig, JSON.stringify(config, null, 2), { encoding: 'utf8' });
+            tsconfigGenerated = true;
         }
         if (!tsconfig)
             (0, error_1.raise)('tsconfig is not specified');
-        const { sourcesTypesGeneratorConfig, files, definitions, namesBySourceFile } = await (0, types_generator_1.generateDraftTypeFiles)({
+        const { sourcesTypesGeneratorConfig, files, definitions, namesBySourceFile } = await (0, generate_drafts_1.generateDraftTypeFiles)({
             ...options,
             tsconfig,
             sourcesPattern,
         });
-        const refs = definitions.map((item) => (0, index_1.buildSchemaDefinitionRef)(item, options.schemaId));
+        const refs = definitions.map((item) => (0, ref_1.buildSchemaDefinitionRef)(item, options.schemaId));
         let schema;
         try {
             {
                 schema = {
-                    ...(await (0, schema_generator_1.generateSchemaByDraftTypes)({
-                        schemaId,
+                    ...(await (0, generate_schema_1.generateSchemaByDraftTypes)({
                         tsconfig,
                         definitions,
-                        sourcesDirectoryPattern,
-                        outputSchemaFile,
                         sourcesTypesGeneratorConfig,
-                        expose: options.expose,
-                        openapiCompatible: options.openapiCompatible,
-                        sortObjectProperties: options.sortObjectProperties,
-                        allowUseFallbackDescription: options.allowUseFallbackDescription,
-                        shrinkDefinitionNames: options.shrinkDefinitionNames,
+                        ...options,
                     })),
                     ...(options.schemaMetadata || {}),
                 };
@@ -88,13 +77,13 @@ async function forgeSchema(options) {
                 };
                 const defs = new Set(Object.keys((schema.definitions || {})));
                 for (const name of definitions) {
-                    const ref = (0, index_1.buildSchemaDefinitionRef)(name, schemaId);
+                    const ref = (0, ref_1.buildSchemaDefinitionRef)(name, options.schemaId);
                     map.names[name] = ref;
                     map.refs[ref] = name;
                     defs.delete(name);
                 }
                 for (const name of defs) {
-                    const ref = (0, index_1.buildSchemaDefinitionRef)(name, options.schemaId);
+                    const ref = (0, ref_1.buildSchemaDefinitionRef)(name, options.schemaId);
                     map.serviceNames[name] = ref;
                     map.serviceRefs[ref] = name;
                 }
@@ -105,7 +94,7 @@ async function forgeSchema(options) {
             }
         }
         finally {
-            if (!KEEP_ARTEFACTS) {
+            if (!artefacts_policy_1.KEEP_GEN_ARTEFACTS) {
                 await Promise.all(files.map((fileName) => (0, promises_1.unlink)(fileName).catch(noop_1.noop)));
             }
         }
@@ -122,12 +111,3 @@ async function forgeSchema(options) {
         }
     }
 }
-async function loadJSONSchema(files) {
-    return Promise.all(files.map((fn) => (0, promises_1.readFile)(fn, { encoding: 'utf8' }).then(JSON.parse)));
-}
-function loadJSONSchemaSync(files) {
-    return files.map((fn) => {
-        const content = (0, node_fs_1.readFileSync)(fn, { encoding: 'utf8' });
-        return JSON.parse(content);
-    });
-}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=forge.spec.d.ts.map

package/lib/schema-generator/forge.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge.spec.d.ts","sourceRoot":"","sources":["../../src/schema-generator/forge.spec.ts"],"names":[],"mappings":""}