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

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

@@ -4,12 +4,59 @@ 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");
-const KEEP_ARTEFACTS = false;
+const artefacts_policy_1 = require("../artefacts-policy");
+const types_1 = require("../definition-info/types");
+const efc_1 = require("../efc");
+const loader_1 = require("../schema-registry/loader");
+const registry_1 = require("../schema-registry/registry");
+const forge_1 = require("./forge");
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+describe('generator for a8', () => {
+    const outputSchemaFile = './a8.generated.schema.tmp.json';
+    const outputSchemaMetadataFile = './a8.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, forge_1.forgeSchema)({
+            schemaId: 'test',
+            allowUseFallbackDescription: true,
+            tsconfigFrom: './tsconfig.build-test.json',
+            sourcesDirectoryPattern: 'test-sources/a8',
+            sourcesFilesPattern: ['service-api.ts', 'types.ts'],
+            outputSchemaFile,
+            outputSchemaMetadataFile,
+            expose: 'all',
+            explicitPublic: true,
+            schemaMetadata,
+        });
+        validator = (0, registry_1.createSchemaForgeRegistry)();
+        loadedSchema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        validator.addSchema(loadedSchema);
+    });
+    afterAll(async () => {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
+            await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
+            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/TypeFromJSON');
+        expect(schema).toBeTruthy();
+    });
+});
 describe('generator for a7', () => {
     const outputSchemaFile = './a7.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a7.generated.definitions.tmp.json';
@@ -19,10 +66,10 @@ describe('generator for a7', () => {
         $comment: 'WARN: This is a test schema.',
     };
     let forgeSchemaResult;
-    let validator;
+    let registry;
     let loadedSchema;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             schemaId: 'test',
             allowUseFallbackDescription: true,
             tsconfigFrom: './tsconfig.build-test.json',
@@ -34,12 +81,12 @@ describe('generator for a7', () => {
             explicitPublic: true,
             schemaMetadata,
         });
-        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        loadedSchema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
-        validator.addSchema(loadedSchema);
+        registry = (0, registry_1.createSchemaForgeRegistry)();
+        loadedSchema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        registry.addSchema(loadedSchema);
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -51,7 +98,7 @@ describe('generator for a7', () => {
     });
     it('generated schema should be valid', () => {
         expect(forgeSchemaResult).toBeTruthy();
-        const schema = validator.getSchema('test#/definitions/SomeAPI_doSomeWithUser_Args');
+        const schema = registry.getSchema('test#/definitions/SomeAPI_doSomeWithUser__APIMethodArgs');
         expect(schema).toBeTruthy();
         expect(schema.items).toStrictEqual([
             { $ref: '#/definitions/User', title: 'user', description: 'Target user' },
@@ -66,10 +113,10 @@ describe('generator for a7', () => {
 describe('validator for a7', () => {
     const outputSchemaFile = './a7.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a7.generated.definitions.tmp.json';
-    let validator;
+    let registry;
     let loadedSchema;
     beforeAll(async () => {
-        await (0, generator_1.forgeSchema)({
+        await (0, forge_1.forgeSchema)({
             schemaId: 'test',
             allowUseFallbackDescription: true,
             tsconfigFrom: './tsconfig.build-test.json',
@@ -80,38 +127,38 @@ describe('validator for a7', () => {
             expose: 'all',
             explicitPublic: true,
         });
-        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        loadedSchema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
-        validator.addSchema(loadedSchema);
+        registry = (0, registry_1.createSchemaForgeRegistry)();
+        loadedSchema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        registry.addSchema(loadedSchema);
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_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;
+        const initial = registry.compilationArtifactCount;
         expect(initial).toStrictEqual(2);
-        validator.warmupCacheSync();
-        const warmed = validator.compilationArtifactCount;
+        registry.warmupCacheSync();
+        const warmed = registry.compilationArtifactCount;
         expect(warmed).toStrictEqual(9);
-        validator.clear();
-        const cleared = validator.compilationArtifactCount;
+        registry.clear();
+        const cleared = registry.compilationArtifactCount;
         expect(cleared).toStrictEqual(1);
-        validator.addSchema(loadedSchema);
-        expect(validator.compilationArtifactCount).toStrictEqual(initial);
-        await validator.warmupCache();
-        expect(validator.compilationArtifactCount).toStrictEqual(warmed);
+        registry.addSchema(loadedSchema);
+        expect(registry.compilationArtifactCount).toStrictEqual(initial);
+        await registry.warmupCache();
+        expect(registry.compilationArtifactCount).toStrictEqual(warmed);
     });
 });
 describe('generator for a6', () => {
     const outputSchemaFile = './a6.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a6.generated.definitions.tmp.json';
     let forgeSchemaResult;
-    let validator;
+    let registry;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             schemaId: 'test',
             tsconfigFrom: './tsconfig.build-test.json',
             sourcesDirectoryPattern: 'test-sources/a6',
@@ -121,12 +168,12 @@ describe('generator for a6', () => {
             expose: 'all',
             explicitPublic: true,
         });
-        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        const schema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
-        validator.addSchema(schema);
+        registry = (0, registry_1.createSchemaForgeRegistry)();
+        const schema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        registry.addSchema(schema);
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -135,24 +182,24 @@ describe('generator for a6', () => {
         expect(forgeSchemaResult).toBeTruthy();
         const defs = forgeSchemaResult?.schema?.definitions;
         expect(defs).toBeTruthy();
-        expect(validator.getValidator('test#/definitions/CollectionItemID1').schema).toStrictEqual({
+        expect(registry.getValidator('test#/definitions/CollectionItemID1').schema).toStrictEqual({
             $ref: '#/definitions/UUID',
             format: 'uuid',
             description: 'This is Collection item ID (inherits from UUID)',
         });
-        expect(validator.getValidator('test#/definitions/CollectionItemID2').schema).toStrictEqual({
+        expect(registry.getValidator('test#/definitions/CollectionItemID2').schema).toStrictEqual({
             format: 'uuid',
             type: 'string',
         });
         {
-            const rec = validator.getValidator('test#/definitions/PRec<CollectionItem,UUID>').schema;
+            const rec = registry.getValidator('test#/definitions/PRec<CollectionItem,UUID>').schema;
             expect(rec).toBeTruthy();
             expect(rec.propertyNames).toStrictEqual({
                 format: 'uuid',
             });
         }
         {
-            const rec = validator.getValidator('test#/definitions/PRec<CollectionItem,CollectionItemID1>').schema;
+            const rec = registry.getValidator('test#/definitions/PRec<CollectionItem,CollectionItemID1>').schema;
             expect(rec).toBeTruthy();
             expect(rec.propertyNames).toStrictEqual({
                 format: 'uuid',
@@ -165,9 +212,9 @@ describe('generator for a5', () => {
     const outputSchemaFile = './a5.generated.schema.tmp.json';
     const outputSchemaMetadataFile = './a5.generated.definitions.tmp.json';
     let forgeSchemaResult;
-    let validator;
+    let registry;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             schemaId: 'test',
             tsconfigFrom: './tsconfig.build-test.json',
             sourcesDirectoryPattern: 'test-sources/a5',
@@ -182,12 +229,12 @@ describe('generator for a5', () => {
                 return undefined;
             },
         });
-        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        const schema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
-        validator.addSchema(schema);
+        registry = (0, registry_1.createSchemaForgeRegistry)();
+        const schema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        registry.addSchema(schema);
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -210,12 +257,14 @@ describe('generator for a5', () => {
             'VariadicList',
             'VariadicList1',
         ]);
-        expect(validator.getValidator('test#/definitions/NT').schema).toStrictEqual({
+        expect(registry.getValidator('test#/definitions/NT').schema).toStrictEqual({
             type: 'string',
             enum: ['v:name1', 'v:name2'],
         });
-        expect(validator.getValidator('test#/definitions/NamesTypeAbnormal').schema).toStrictEqual({ type: 'string' });
-        expect(validator.getValidator('test#/definitions/Some').schema).toStrictEqual({
+        expect(registry.getValidator('test#/definitions/NamesTypeAbnormal').schema).toStrictEqual({
+            type: 'string',
+        });
+        expect(registry.getValidator('test#/definitions/Some').schema).toStrictEqual({
             type: 'object',
             properties: {
                 vals: {
@@ -308,7 +357,7 @@ describe('generator for a4', () => {
     const outputSchemaMetadataFile = './a4.generated.definitions.tmp.json';
     let forgeSchemaResult;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             tsconfigFrom: './tsconfig.build-test.json',
             sourcesDirectoryPattern: 'test-sources/a4',
             sourcesFilesPattern: 'service-api.ts',
@@ -319,7 +368,7 @@ describe('generator for a4', () => {
         });
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -336,7 +385,7 @@ describe('generator for a3', () => {
     const outputSchemaMetadataFile = './a3.generated.definitions.tmp.json';
     let forgeSchemaResult;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             tsconfigFrom: './tsconfig.build-test.json',
             sourcesDirectoryPattern: 'test-sources/a3',
             sourcesFilesPattern: 'service-api.ts',
@@ -346,7 +395,7 @@ describe('generator for a3', () => {
         });
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -354,47 +403,52 @@ describe('generator for a3', () => {
     it('generated schema should be valid', () => {
         expect(forgeSchemaResult).toBeTruthy();
     });
+    it('should generate root schema normally', () => {
+        const registry = (0, registry_1.createSchemaForgeRegistry)({
+            engine: { schemas: [forgeSchemaResult.schema] },
+        });
+        expect(registry.getRootSchema('')).toBeTruthy();
+    });
     it('interface generics should works', () => {
-        const props = forgeSchemaResult.schema.definitions?.InterfaceWithGeneric_InterfaceDeclaration
-            .properties;
+        const props = forgeSchemaResult.schema.definitions?.InterfaceWithGeneric__APIInterface.properties;
         expect(props).toBeTruthy();
         expect(props.propWithGeneric).toBeTruthy();
         expect(props.propWithGeneric.$ref).toStrictEqual('#/definitions/NonEmptyString');
     });
     it('optional args in API methods should works', () => {
         {
-            const props = forgeSchemaResult.schema.definitions?.API_methodG0_Args;
+            const props = forgeSchemaResult.schema.definitions?.API_methodG0__APIMethodArgs;
             expect(props).toBeTruthy();
             expect(props.minItems).toStrictEqual(0);
             expect(props.maxItems).toStrictEqual(1);
         }
         {
-            const props = forgeSchemaResult.schema.definitions?.API_methodG1_Args;
+            const props = forgeSchemaResult.schema.definitions?.API_methodG1__APIMethodArgs;
             expect(props).toBeTruthy();
             expect(props.minItems).toStrictEqual(0);
             expect(props.maxItems).toStrictEqual(2);
         }
         {
-            const props = forgeSchemaResult.schema.definitions?.API_methodG2_Args;
+            const props = forgeSchemaResult.schema.definitions?.API_methodG2__APIMethodArgs;
             expect(props).toBeTruthy();
             expect(props.minItems).toStrictEqual(1);
             expect(props.maxItems).toStrictEqual(2);
         }
         // {
-        //     const props = forgeSchemaResult!.schema.definitions?.API_methodG3_Args;
+        //     const props = forgeSchemaResult!.schema.definitions?.API_methodG3__APIMethodArgs;
         //     expect(props).toBeTruthy();
         //     expect(props.minItems).toStrictEqual(0);
         //     expect(props.maxItems).toBeUndefined();
         // }
         // {
-        //     const props = forgeSchemaResult!.schema.definitions?.API_methodG4_Args;
+        //     const props = forgeSchemaResult!.schema.definitions?.API_methodG4__APIMethodArgs;
         //     expect(props).toBeTruthy();
         //     expect(props.minItems).toStrictEqual(1);
         //     expect(props.maxItems).toBeUndefined();
         // }
     });
     it('extends should works', () => {
-        const props = forgeSchemaResult.schema.definitions?.BAPI_InterfaceDeclaration.properties;
+        const props = forgeSchemaResult.schema.definitions?.BAPI__APIInterface.properties;
         expect(props).toBeTruthy();
         expect(Object.keys(props)).toStrictEqual([
             'propertyA',
@@ -419,7 +473,7 @@ describe('generator for a2', () => {
     const outputSchemaMetadataFile = './a2.generated.definitions.tmp.json';
     let forgeSchemaResult;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             tsconfigFrom: './tsconfig.build-test.json',
             sourcesDirectoryPattern: 'test-sources/a2',
             sourcesFilesPattern: 'service-api.ts',
@@ -428,7 +482,7 @@ describe('generator for a2', () => {
         });
     });
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -444,7 +498,7 @@ describe('generator for a1', () => {
     let forgeSchemaResult;
     let validator;
     beforeAll(async () => {
-        forgeSchemaResult = await (0, generator_1.forgeSchema)({
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
             allowUseFallbackDescription: false,
             explicitPublic: true,
             schemaId,
@@ -454,12 +508,12 @@ describe('generator for a1', () => {
             outputSchemaFile,
             outputSchemaMetadataFile,
         });
-        validator = (0, validator_1.createSchemaForgeValidator)({}, true);
-        const schema = await (0, generator_1.loadJSONSchema)([outputSchemaFile]);
+        validator = (0, registry_1.createSchemaForgeRegistry)();
+        const schema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
         validator.addSchema(schema);
     }, 10_000);
     afterAll(async () => {
-        if (!KEEP_ARTEFACTS) {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
             await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
             await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
         }
@@ -490,16 +544,16 @@ describe('generator for a1', () => {
         });
     });
     it('hasSchema', () => {
-        expect(validator.hasValidator('test#/definitions/SomeType1')).toStrictEqual(true);
-        expect(validator.hasValidator('test#/definitions/PositiveInt')).toStrictEqual(true);
-        expect(validator.hasValidator('test#/definitions/Int')).toStrictEqual(false);
-        expect(validator.hasValidator('test#/definitions/!Int')).toStrictEqual(false);
+        expect(validator.hasSchema('test#/definitions/SomeType1')).toStrictEqual(true);
+        expect(validator.hasSchema('test#/definitions/PositiveInt')).toStrictEqual(true);
+        expect(validator.hasSchema('test#/definitions/Int')).toStrictEqual(false);
+        expect(validator.hasSchema('test#/definitions/!Int')).toStrictEqual(false);
     });
     it('checkBySchema', () => {
-        expect(() => validator.checkBySchema('test#/definitions/ExportedInterfaceB_InterfaceDeclaration', {})).toThrow(types_1.SchemaForgeValidationErrorCode);
+        expect(() => validator.checkBySchema('test#/definitions/ExportedInterfaceB__APIInterface', {})).toThrow(efc_1.SchemaForgeErrors.msg('EC_SF_VALIDATION_FAILED'));
         expect(validator.checkBySchema('test#/definitions/PositiveInt', 1)).toStrictEqual(true);
-        expect(() => validator.checkBySchema('test#/definitions/PositiveInt', 1.1)).toThrow(types_1.SchemaForgeValidationErrorCode);
-        expect(() => validator.checkBySchema('!test#/definitions/PositiveInt', 1)).toThrow(types_1.SchemaNotFoundErrorCode);
+        expect(() => validator.checkBySchema('test#/definitions/PositiveInt', 1.1)).toThrow(efc_1.SchemaForgeErrors.msg('EC_SF_VALIDATION_FAILED'));
+        expect(() => validator.checkBySchema('!test#/definitions/PositiveInt', 1)).toThrow(efc_1.SchemaForgeErrors.msg('EC_SF_SCHEMA_NOT_FOUND'));
         {
             const schema = '!test#/definitions/Int';
             try {
@@ -508,8 +562,8 @@ describe('generator for a1', () => {
             catch (e) {
                 const context = (0, error_1.readErrorContext)(e);
                 const code = (0, error_1.readErrorCode)(e);
-                expect(e.message).toStrictEqual(types_1.SchemaNotFoundErrorCode);
-                expect(code).toStrictEqual(types_1.SchemaNotFoundErrorCode);
+                expect(e.message).toStrictEqual(efc_1.SchemaForgeErrors.msg('EC_SF_SCHEMA_NOT_FOUND'));
+                expect(code).toStrictEqual('EC_SF_SCHEMA_NOT_FOUND');
                 expect(context).toBeTruthy();
                 expect(context.schema).toStrictEqual(schema);
                 expect(context.errorMessage).toStrictEqual(undefined);
@@ -524,8 +578,8 @@ describe('generator for a1', () => {
             catch (e) {
                 const context = (0, error_1.readErrorContext)(e);
                 const code = (0, error_1.readErrorCode)(e);
-                expect(e.message).toStrictEqual(message);
-                expect(code).toStrictEqual(types_1.SchemaForgeValidationErrorCode);
+                expect(code).toStrictEqual('EC_SF_VALIDATION_FAILED');
+                expect(e.message).toStrictEqual(efc_1.SchemaForgeErrors.msg(code));
                 expect(context).toBeTruthy();
                 expect(context.schema).toStrictEqual(schema);
                 expect(context.errorMessage).toStrictEqual(message);
@@ -536,63 +590,63 @@ describe('generator for a1', () => {
     it('listDefinitions', () => {
         const defs = [
             {
-                ref: 'test#/definitions/ExportedInterfaceB_InterfaceDeclaration',
+                ref: 'test#/definitions/ExportedInterfaceB__APIInterface',
                 kind: 1,
-                name: 'ExportedInterfaceB_InterfaceDeclaration',
+                name: 'ExportedInterfaceB__APIInterface',
                 schemaId: 'test',
                 interface: 'ExportedInterfaceB',
             },
             {
-                ref: 'test#/definitions/ExportedInterfaceB_methodA_Args',
+                ref: 'test#/definitions/ExportedInterfaceB_methodA__APIMethodArgs',
                 kind: 3,
-                name: 'ExportedInterfaceB_methodA_Args',
+                name: 'ExportedInterfaceB_methodA__APIMethodArgs',
                 schemaId: 'test',
                 interface: 'ExportedInterfaceB',
                 method: 'methodA',
             },
             {
-                ref: 'test#/definitions/ExportedInterfaceB_methodA_Result',
+                ref: 'test#/definitions/ExportedInterfaceB_methodA__APIMethodResult',
                 kind: 2,
-                name: 'ExportedInterfaceB_methodA_Result',
+                name: 'ExportedInterfaceB_methodA__APIMethodResult',
                 schemaId: 'test',
                 interface: 'ExportedInterfaceB',
                 method: 'methodA',
             },
             {
-                ref: 'test#/definitions/ExportedInterfaceB_methodB_Args',
+                ref: 'test#/definitions/ExportedInterfaceB_methodB__APIMethodArgs',
                 kind: 3,
-                name: 'ExportedInterfaceB_methodB_Args',
+                name: 'ExportedInterfaceB_methodB__APIMethodArgs',
                 schemaId: 'test',
                 interface: 'ExportedInterfaceB',
                 method: 'methodB',
             },
             {
-                ref: 'test#/definitions/ExportedInterfaceB_methodB_Result',
+                ref: 'test#/definitions/ExportedInterfaceB_methodB__APIMethodResult',
                 kind: 2,
-                name: 'ExportedInterfaceB_methodB_Result',
+                name: 'ExportedInterfaceB_methodB__APIMethodResult',
                 schemaId: 'test',
                 interface: 'ExportedInterfaceB',
                 method: 'methodB',
             },
             {
-                ref: 'test#/definitions/NonExportedInterfaceD_InterfaceDeclaration',
+                ref: 'test#/definitions/NonExportedInterfaceD__APIInterface',
                 kind: 1,
-                name: 'NonExportedInterfaceD_InterfaceDeclaration',
+                name: 'NonExportedInterfaceD__APIInterface',
                 schemaId: 'test',
                 interface: 'NonExportedInterfaceD',
             },
             {
-                ref: 'test#/definitions/NonExportedInterfaceD_methodA_Args',
+                ref: 'test#/definitions/NonExportedInterfaceD_methodA__APIMethodArgs',
                 kind: 3,
-                name: 'NonExportedInterfaceD_methodA_Args',
+                name: 'NonExportedInterfaceD_methodA__APIMethodArgs',
                 schemaId: 'test',
                 interface: 'NonExportedInterfaceD',
                 method: 'methodA',
             },
             {
-                ref: 'test#/definitions/NonExportedInterfaceD_methodA_Result',
+                ref: 'test#/definitions/NonExportedInterfaceD_methodA__APIMethodResult',
                 kind: 2,
-                name: 'NonExportedInterfaceD_methodA_Result',
+                name: 'NonExportedInterfaceD_methodA__APIMethodResult',
                 schemaId: 'test',
                 interface: 'NonExportedInterfaceD',
                 method: 'methodA',
@@ -624,24 +678,24 @@ describe('generator for a1', () => {
             defsByName[def.name] = def;
         }
         expect(validator.listDefinitions()).toStrictEqual(defs);
-        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionKind.Type && !info.name.startsWith('Some'))).toStrictEqual([defsByName['PositiveInt']]);
-        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionKind.API)).toStrictEqual([
-            defsByName['ExportedInterfaceB_InterfaceDeclaration'],
-            defsByName['NonExportedInterfaceD_InterfaceDeclaration'],
+        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionInfoKind.Type && !info.name.startsWith('Some'))).toStrictEqual([defsByName['PositiveInt']]);
+        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionInfoKind.API)).toStrictEqual([
+            defsByName['ExportedInterfaceB__APIInterface'],
+            defsByName['NonExportedInterfaceD__APIInterface'],
         ]);
-        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionKind.APIMethodResult)).toStrictEqual([
-            defsByName['ExportedInterfaceB_methodA_Result'],
-            defsByName['ExportedInterfaceB_methodB_Result'],
-            defsByName['NonExportedInterfaceD_methodA_Result'],
+        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionInfoKind.APIMethodResult)).toStrictEqual([
+            defsByName['ExportedInterfaceB_methodA__APIMethodResult'],
+            defsByName['ExportedInterfaceB_methodB__APIMethodResult'],
+            defsByName['NonExportedInterfaceD_methodA__APIMethodResult'],
         ]);
-        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionKind.APIMethodArguments)).toStrictEqual([
-            defsByName['ExportedInterfaceB_methodA_Args'],
-            defsByName['ExportedInterfaceB_methodB_Args'],
-            defsByName['NonExportedInterfaceD_methodA_Args'],
+        expect(validator.listDefinitions((info) => info.kind === types_1.SchemaDefinitionInfoKind.APIMethodArguments)).toStrictEqual([
+            defsByName['ExportedInterfaceB_methodA__APIMethodArgs'],
+            defsByName['ExportedInterfaceB_methodB__APIMethodArgs'],
+            defsByName['NonExportedInterfaceD_methodA__APIMethodArgs'],
         ]);
     });
     it('should be valid descriptions', () => {
-        const schema = validator.getSchema('test#/definitions/ExportedInterfaceB_InterfaceDeclaration');
+        const schema = validator.getSchema('test#/definitions/ExportedInterfaceB__APIInterface');
         expect(schema).toBeTruthy();
         expect(schema.description).toStrictEqual('TAG: Description for ExportedInterfaceB');
         expect(schema.properties.propertyA.description).toStrictEqual('Description for propertyA');

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

@@ -0,0 +1,2 @@
+export declare function formatForgeSchemaError(error: Error, dir?: string): string;
+//# sourceMappingURL=format-error.d.ts.map

package/lib/schema-generator/format-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-error.d.ts","sourceRoot":"","sources":["../../src/schema-generator/format-error.ts"],"names":[],"mappings":"AAGA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,SAAK,UAU5D"}

package/lib/{util/format.error.js → schema-generator/format-error.js}

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatSchemaForgeError = formatSchemaForgeError;
+exports.formatForgeSchemaError = formatForgeSchemaError;
 const ts_json_schema_generator_1 = require("ts-json-schema-generator");
 const typescript_1 = require("typescript");
-function formatSchemaForgeError(error, dir = '') {
+function formatForgeSchemaError(error, dir = '') {
     if (error instanceof ts_json_schema_generator_1.BaseError) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
         return (0, typescript_1.formatDiagnostics)(error.diagnostic.relatedInformation || [], {
             getCanonicalFileName: (fileName) => fileName,
             getCurrentDirectory: () => dir,

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

@@ -0,0 +1,17 @@
+import { type CompletedConfig } from 'ts-json-schema-generator/dist/src/Config';
+import { ForgeSchemaOptions } from '../types';
+/**
+ * @internal
+ */
+export declare function generateDraftTypeFiles(options: SFDTGOptions): Promise<{
+    files: string[];
+    definitions: string[];
+    sourcesTypesGeneratorConfig: CompletedConfig;
+    namesBySourceFile: Map<string, Set<string>>;
+}>;
+interface SFDTGOptions extends ForgeSchemaOptions {
+    tsconfig: string;
+    sourcesPattern: string[];
+}
+export {};
+//# sourceMappingURL=generate-drafts.d.ts.map

package/lib/schema-generator/generate-drafts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-drafts.d.ts","sourceRoot":"","sources":["../../src/schema-generator/generate-drafts.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,0CAA0C,CAAC;AAmChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAW9C;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,YAAY;;;;;GAiCjE;AA2WD,UAAU,YAAa,SAAQ,kBAAkB;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC5B"}