@goast/core 0.3.2 → 0.3.4

package/cjs/lib/codegen/config.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOpenApiGeneratorConfig = void 0;
+const types_1 = require("../transform/types");
 const source_builder_1 = require("../utils/source-builder");
 exports.defaultOpenApiGeneratorConfig = {
     ...source_builder_1.defaultSourceBuilderOptions,
+    ...types_1.defaultOpenApiTransformerOptions,
     outputDir: 'generated',
     clearOutputDir: true,
 };

package/cjs/lib/codegen/generator.js

@@ -59,7 +59,11 @@ class _OpenApiGenerator {
 }
 class OpenApiGenerator extends _OpenApiGenerator {
     constructor(config) {
-        super({ ...config_1.defaultOpenApiGeneratorConfig, ...config }, [], new parser_1.OpenApiParser());
+        super(...OpenApiGenerator.getCtorArgs(config));
+    }
+    static getCtorArgs(config) {
+        const c = { ...config_1.defaultOpenApiGeneratorConfig, ...config };
+        return [c, [], new parser_1.OpenApiParser(c)];
     }
 }
 exports.OpenApiGenerator = OpenApiGenerator;

package/cjs/lib/parse/parser.js

@@ -9,12 +9,14 @@ const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const yaml_1 = tslib_1.__importDefault(require("yaml"));
 const deref_proxy_1 = require("./deref-proxy");
+const types_1 = require("./types");
 const collector_1 = require("../collect/collector");
 const transformer_1 = require("../transform/transformer");
 const utils_1 = require("../utils");
 class OpenApiParser {
-    constructor() {
+    constructor(config) {
         this._loadedDocuments = new Map();
+        this._config = { ...types_1.defaultOpenApiParserOptions, ...config };
     }
     async parseApisAndTransform(...fileNames) {
         const flatFileNames = [].concat(...fileNames);
@@ -29,7 +31,7 @@ class OpenApiParser {
     }
     transformApis(apis) {
         const collectedData = (0, collector_1.collectOpenApi)(apis);
-        const transformedData = (0, transformer_1.transformOpenApi)(collectedData);
+        const transformedData = (0, transformer_1.transformOpenApi)(collectedData, this._config);
         return transformedData;
     }
     async dereference(file, path, value) {

package/cjs/lib/parse/types.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpenApiParserOptions = void 0;
+const types_1 = require("../transform/types");
+exports.defaultOpenApiParserOptions = { ...types_1.defaultOpenApiTransformerOptions };

package/cjs/lib/transform/helpers.js

@@ -11,13 +11,15 @@ exports.transformAdditionalProperties = transformAdditionalProperties;
 exports.transformSchemaProperties = transformSchemaProperties;
 exports.getOpenApiObjectIdentifier = getOpenApiObjectIdentifier;
 const internal_utils_1 = require("../internal-utils");
+const utils_1 = require("../utils");
 const common_utils_1 = require("../utils/common.utils");
-function determineSchemaKind(schema) {
+function determineSchemaKind(ctx, schema) {
     if (schema.oneOf) {
         return 'oneOf';
     }
     else if (schema.type !== 'object' && (schema.allOf || schema.anyOf)) {
-        return 'combined';
+        const hasProperties = (schema.properties && Object.keys(schema.properties).length > 0) || schema.additionalProperties;
+        return hasProperties ? 'object' : 'combined';
     }
     else if (Array.isArray(schema.type)) {
         return 'multi-type';
@@ -31,9 +33,14 @@ function determineSchemaKind(schema) {
         schema.type === 'array') {
         return schema.type;
     }
-    return 'unknown';
+    const treadAsObject = ctx.config.unknownTypeBehavior === 'always-object' ||
+        (ctx.config.unknownTypeBehavior === 'object-if-properties' &&
+            schema.properties &&
+            Object.keys(schema.properties).length > 0);
+    return treadAsObject ? 'object' : 'unknown';
 }
 function determineSchemaName(schema, id) {
+    var _a, _b, _c, _d, _e, _f;
     if (schema.title)
         return { name: schema.title, isGenerated: false };
     if (!schema.$src) {
@@ -46,7 +53,34 @@ function determineSchemaName(schema, id) {
     const responseMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/responses\/(?<status>\d+)\//);
     if (responseMatch && responseMatch.groups) {
         const { path, method, status } = responseMatch.groups;
-        return { name: `${method}_${path.replace(/\//g, '_')}_${status}_Response`, isGenerated: true };
+        const operation = (_c = (_b = (_a = schema.$src.document.paths) === null || _a === void 0 ? void 0 : _a[path]) === null || _b === void 0 ? void 0 : _b[method]) !== null && _c !== void 0 ? _c : {};
+        return {
+            name: `${determineEndpointName({ method, path: `/${path}`, operation })}_${status}_Response`,
+            isGenerated: true,
+        };
+    }
+    const responseCompMatch = schema.$src.path.match(/\/components\/responses\/([^/]+)\/content\/.+\/schema/);
+    if (responseCompMatch) {
+        return {
+            name: responseCompMatch[1].toLowerCase().endsWith('response')
+                ? responseCompMatch[1]
+                : responseCompMatch[1] + 'Response',
+            isGenerated: true,
+        };
+    }
+    const requestBodyMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/requestBody\//);
+    if (requestBodyMatch && requestBodyMatch.groups) {
+        const { path, method } = requestBodyMatch.groups;
+        const operation = (_f = (_e = (_d = schema.$src.document.paths) === null || _d === void 0 ? void 0 : _d[path]) === null || _e === void 0 ? void 0 : _e[method]) !== null && _f !== void 0 ? _f : {};
+        return { name: `${determineEndpointName({ method, path: `/${path}`, operation })}_Request`, isGenerated: true };
+    }
+    const parentSchemaMatch = schema.$src.path.match(/(.*)\/properties\/([^/]*)$/);
+    if (parentSchemaMatch) {
+        const parentSchema = (0, utils_1.getDeepProperty)(schema.$src.document, parentSchemaMatch[1].split('/').filter(Boolean));
+        const parentSchemaName = determineSchemaName({ title: parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title, $src: { path: parentSchemaMatch[1], document: schema.$src.document } }, id);
+        if (!parentSchemaName.isGenerated) {
+            return { name: `${parentSchemaName.name}_${parentSchemaMatch[2]}`, isGenerated: true };
+        }
     }
     return { name: id, isGenerated: true };
 }

package/cjs/lib/transform/transform-schema.js

@@ -3,20 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSchema = transformSchema;
 const helpers_1 = require("./helpers");
 const utils_1 = require("../utils");
-function transformSchema(context, schema) {
+function transformSchema(ctx, schema) {
     var _a, _b;
     if (!schema) {
         throw new Error('Schema is required.');
     }
     const schemaSource = `${schema.$src.file}:${schema.$src.path}`;
-    const existingSchema = (_a = context.schemas.get(schemaSource)) !== null && _a !== void 0 ? _a : context.incompleteSchemas.get(schemaSource);
+    const existingSchema = (_a = ctx.schemas.get(schemaSource)) !== null && _a !== void 0 ? _a : ctx.incompleteSchemas.get(schemaSource);
     if (existingSchema)
         return existingSchema;
     const openApiObjectId = (0, helpers_1.getOpenApiObjectIdentifier)(schema);
-    const existing = context.transformed.schemas.get(openApiObjectId);
+    const existing = ctx.transformed.schemas.get(openApiObjectId);
     if (existing)
         return existing;
-    let kind = (0, helpers_1.determineSchemaKind)(schema);
+    let kind = (0, helpers_1.determineSchemaKind)(ctx, schema);
     let nullable = kind === 'null';
     if (kind === 'multi-type') {
         const types = schema.type;
@@ -30,13 +30,13 @@ function transformSchema(context, schema) {
             const newType = types.filter((t) => t !== 'null' && t !== null)[0];
             schema = (0, utils_1.createOverwriteProxy)(schema);
             schema.type = newType;
-            kind = (0, helpers_1.determineSchemaKind)(schema);
+            kind = (0, helpers_1.determineSchemaKind)(ctx, schema);
         }
         else {
             schema.type = types.filter((t) => t !== 'null' && t !== null);
         }
     }
-    const id = context.idGenerator.generateId('schema');
+    const id = ctx.idGenerator.generateId('schema');
     const nameInfo = (0, helpers_1.determineSchemaName)(schema, id);
     const incompleteSchema = {
         $src: {
@@ -57,7 +57,7 @@ function transformSchema(context, schema) {
         nullable: nullable || schema.nullable === true,
         required: new Set(schema.required),
         custom: (0, helpers_1.getCustomFields)(schema),
-        not: schema.not ? transformSchema(context, schema.not) : undefined,
+        not: schema.not ? transformSchema(ctx, schema.not) : undefined,
         const: schema.const,
         discriminator: schema.discriminator
             ? {
@@ -67,101 +67,117 @@ function transformSchema(context, schema) {
             : undefined,
         inheritedSchemas: [],
     };
-    context.incompleteSchemas.set(schemaSource, incompleteSchema);
+    ctx.incompleteSchemas.set(schemaSource, incompleteSchema);
     if (schema.$ref) {
-        incompleteSchema.$ref = transformSchema(context, schema.$ref);
+        incompleteSchema.$ref = transformSchema(ctx, schema.$ref);
     }
-    const extensions = schemaTransformers[kind](schema, context);
+    const extensions = schemaTransformers[kind](schema, ctx);
     const completeSchema = Object.assign(incompleteSchema, extensions);
-    resolveDescriminatorMapping(context, completeSchema);
-    context.incompleteSchemas.delete(schemaSource);
-    context.transformed.schemas.set(openApiObjectId, completeSchema);
-    context.schemas.set(schemaSource, completeSchema);
+    resolveDescriminatorMapping(ctx, completeSchema);
+    ctx.incompleteSchemas.delete(schemaSource);
+    ctx.transformed.schemas.set(openApiObjectId, completeSchema);
+    ctx.schemas.set(schemaSource, completeSchema);
     return completeSchema;
 }
-const schemaTransformers = {
-    oneOf: (schema, context) => {
-        var _a, _b;
-        return ({
-            oneOf: (_b = (_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-        });
-    },
-    string: (schema) => ({
-        type: 'string',
+function allExtensionsTransformer(schema, context) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        oneOf: (_b = (_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
         format: schema.format,
         pattern: schema.pattern,
         minLength: schema.minLength,
         maxLength: schema.maxLength,
-    }),
-    number: (schema) => ({
-        type: 'number',
-        format: schema.format,
         minimum: schema.minimum,
         maximum: schema.maximum,
+        properties: (0, helpers_1.transformSchemaProperties)(context, schema, transformSchema),
+        additionalProperties: (0, helpers_1.transformAdditionalProperties)(context, schema, transformSchema),
+        allOf: (_d = (_c = schema.allOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
+        anyOf: (_f = (_e = schema.anyOf) === null || _e === void 0 ? void 0 : _e.map((s) => transformSchema(context, s))) !== null && _f !== void 0 ? _f : [],
+        items: schema.items ? transformSchema(context, schema.items) : undefined,
+        minItems: schema.minItems,
+        maxItems: schema.maxItems,
+    };
+}
+const schemaTransformers = {
+    oneOf: (schema, context) => ({
+        ...allExtensionsTransformer(schema, context),
+    }),
+    string: (schema, context) => ({
+        type: 'string',
+        ...allExtensionsTransformer(schema, context),
+    }),
+    number: (schema, context) => ({
+        type: 'number',
+        ...allExtensionsTransformer(schema, context),
     }),
-    boolean: (schema) => ({ type: 'boolean', format: schema.format }),
-    object: (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            type: 'object',
-            properties: (0, helpers_1.transformSchemaProperties)(context, schema, transformSchema),
-            format: schema.format,
-            additionalProperties: (0, helpers_1.transformAdditionalProperties)(context, schema, transformSchema),
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-        });
-    },
-    integer: (schema) => ({
+    boolean: (schema, context) => ({ type: 'boolean', ...allExtensionsTransformer(schema, context) }),
+    object: (schema, context) => ({
+        type: 'object',
+        ...allExtensionsTransformer(schema, context),
+    }),
+    integer: (schema, context) => ({
         type: 'integer',
-        format: schema.format,
-        minimum: schema.minimum,
-        maximum: schema.maximum,
+        ...allExtensionsTransformer(schema, context),
     }),
     array: (schema, context) => ({
         type: 'array',
-        items: schema.items ? transformSchema(context, schema.items) : undefined,
-        minItems: schema.minItems,
-        maxItems: schema.maxItems,
+        ...allExtensionsTransformer(schema, context),
+    }),
+    combined: (schema, context) => ({
+        ...allExtensionsTransformer(schema, context),
+    }),
+    'multi-type': (schema, context) => ({
+        type: schema.type,
+        ...allExtensionsTransformer(schema, context),
     }),
-    combined: (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-        });
-    },
-    'multi-type': (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            type: schema.type,
-            items: schema.items ? transformSchema(context, schema.items) : undefined,
-            minItems: schema.minItems,
-            maxItems: schema.maxItems,
-            minimum: schema.minimum,
-            maximum: schema.maximum,
-            format: schema.format,
-            properties: (0, helpers_1.transformSchemaProperties)(context, schema, transformSchema),
-            additionalProperties: (0, helpers_1.transformAdditionalProperties)(context, schema, transformSchema),
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-            maxLength: schema.maxLength,
-            minLength: schema.minLength,
-            pattern: schema.pattern,
-        });
-    },
     null: () => ({ type: 'null' }),
     unknown: () => ({}),
 };
 function resolveDescriminatorMapping(context, schema) {
     const discriminator = schema.$src.component.discriminator;
-    if (!discriminator || typeof discriminator === 'string' || !discriminator.mapping)
-        return;
-    for (const key of Object.keys(discriminator.mapping)) {
-        const mappedSchemaRef = discriminator.mapping[key];
-        const mappedSchema = transformSchema(context, mappedSchemaRef);
-        if (schema.discriminator) {
-            schema.discriminator.mapping[key] = mappedSchema;
-            mappedSchema.inheritedSchemas.push(schema);
+    if (discriminator && typeof discriminator === 'object' && discriminator.mapping) {
+        for (const key of Object.keys(discriminator.mapping)) {
+            const mappedSchemaRef = discriminator.mapping[key];
+            const mappedSchema = transformSchema(context, mappedSchemaRef);
+            if (schema.discriminator) {
+                schema.discriminator.mapping[key] = mappedSchema;
+                const hasInheritedSchema = mappedSchema.inheritedSchemas.some((x) => x.id === schema.id);
+                if (!hasInheritedSchema) {
+                    mappedSchema.inheritedSchemas.push(schema);
+                }
+            }
         }
     }
+    if (schema.kind === 'combined' && schema.allOf) {
+        for (const s of schema.allOf) {
+            const base = findDiscriminatedSchema(s);
+            if (!base)
+                continue;
+            if (base.discriminator && base.discriminator.propertyName) {
+                const origDiscriminator = base.$src.component.discriminator;
+                if (origDiscriminator &&
+                    typeof origDiscriminator === 'object' &&
+                    origDiscriminator.mapping &&
+                    Object.values(origDiscriminator.mapping).some((x) => x.$src.file === schema.$src.file && x.$src.path === schema.$src.path)) {
+                    continue;
+                }
+                const mappingKey = schema.isNameGenerated ? null : schema.name;
+                if (!mappingKey) {
+                    continue;
+                }
+                base.discriminator.mapping[mappingKey] = schema;
+                const hasInheritedSchema = schema.inheritedSchemas.some((x) => x.id === base.id);
+                if (!hasInheritedSchema) {
+                    schema.inheritedSchemas.push(base);
+                }
+            }
+        }
+    }
+}
+function findDiscriminatedSchema(schema) {
+    const origDiscriminator = schema.$src.originalComponent.discriminator;
+    if (origDiscriminator && (typeof origDiscriminator === 'string' || origDiscriminator.propertyName)) {
+        return schema;
+    }
+    return schema.$ref ? findDiscriminatedSchema(schema.$ref) : null;
 }

package/cjs/lib/transform/transformer.js

@@ -5,8 +5,10 @@ const helpers_1 = require("./helpers");
 const transform_document_1 = require("./transform-document");
 const transform_endpoint_1 = require("./transform-endpoint");
 const transform_schema_1 = require("./transform-schema");
-function transformOpenApi(data) {
+const types_1 = require("./types");
+function transformOpenApi(data, options) {
     const context = {
+        config: { ...types_1.defaultOpenApiTransformerOptions, ...options },
         idGenerator: new helpers_1.IdGenerator(),
         input: data,
         incompleteSchemas: new Map(),

package/cjs/lib/transform/types.js

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpenApiTransformerOptions = void 0;
+exports.defaultOpenApiTransformerOptions = {
+    unknownTypeBehavior: 'object-if-properties',
+};

package/cjs/lib/utils/object.utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOverwriteProxy = createOverwriteProxy;
+exports.getDeepProperty = getDeepProperty;
 function createOverwriteProxy(target, values) {
     const proxy = new Proxy(target, new OverwriteProxyHandler());
     if (values) {
@@ -8,6 +9,16 @@ function createOverwriteProxy(target, values) {
     }
     return proxy;
 }
+function getDeepProperty(obj, path) {
+    let current = obj;
+    for (const key of path) {
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
 class OverwriteProxyHandler {
     constructor() {
         this._overwrittenValues = {};

package/cjs/lib/utils/schema.utils.js

@@ -9,6 +9,9 @@ function resolveAnyOfAndAllOf(schema, ignoreNonObjectParts) {
     }
     const required = new Set(schema.required);
     const properties = new Map();
+    if ('properties' in schema) {
+        schema.properties.forEach((prop) => properties.set(prop.name, prop));
+    }
     collectSubSchemaProperties(schema.allOf, properties, required, false);
     collectSubSchemaProperties(schema.anyOf, properties, required, true);
     const initialAdditionalProperties = schema.kind === 'object' ? schema.additionalProperties : undefined;

package/esm/lib/codegen/config.js

@@ -1,6 +1,8 @@
+import { defaultOpenApiTransformerOptions } from '../transform/types';
 import { defaultSourceBuilderOptions } from '../utils/source-builder';
 export const defaultOpenApiGeneratorConfig = {
     ...defaultSourceBuilderOptions,
+    ...defaultOpenApiTransformerOptions,
     outputDir: 'generated',
     clearOutputDir: true,
 };

package/esm/lib/codegen/generator.js

@@ -56,7 +56,11 @@ class _OpenApiGenerator {
 }
 export class OpenApiGenerator extends _OpenApiGenerator {
     constructor(config) {
-        super({ ...defaultOpenApiGeneratorConfig, ...config }, [], new OpenApiParser());
+        super(...OpenApiGenerator.getCtorArgs(config));
+    }
+    static getCtorArgs(config) {
+        const c = { ...defaultOpenApiGeneratorConfig, ...config };
+        return [c, [], new OpenApiParser(c)];
     }
 }
 function mergeDeep(target, ...sources) {

package/esm/lib/parse/parser.js

@@ -5,12 +5,14 @@ import fs from 'fs-extra';
 import nodeFetch from 'node-fetch';
 import YAML from 'yaml';
 import { createDerefProxy } from './deref-proxy';
+import { defaultOpenApiParserOptions } from './types';
 import { collectOpenApi } from '../collect/collector';
 import { transformOpenApi } from '../transform/transformer';
 import { isNullish } from '../utils';
 export class OpenApiParser {
-    constructor() {
+    constructor(config) {
         this._loadedDocuments = new Map();
+        this._config = { ...defaultOpenApiParserOptions, ...config };
     }
     async parseApisAndTransform(...fileNames) {
         const flatFileNames = [].concat(...fileNames);
@@ -25,7 +27,7 @@ export class OpenApiParser {
     }
     transformApis(apis) {
         const collectedData = collectOpenApi(apis);
-        const transformedData = transformOpenApi(collectedData);
+        const transformedData = transformOpenApi(collectedData, this._config);
         return transformedData;
     }
     async dereference(file, path, value) {

package/esm/lib/parse/types.js

@@ -1 +1,2 @@
-export {};
+import { defaultOpenApiTransformerOptions } from '../transform/types';
+export const defaultOpenApiParserOptions = { ...defaultOpenApiTransformerOptions };

package/esm/lib/transform/helpers.js

@@ -1,11 +1,13 @@
 import { isOpenApiObjectProperty } from '../internal-utils';
+import { getDeepProperty } from '../utils';
 import { isNullish } from '../utils/common.utils';
-export function determineSchemaKind(schema) {
+export function determineSchemaKind(ctx, schema) {
     if (schema.oneOf) {
         return 'oneOf';
     }
     else if (schema.type !== 'object' && (schema.allOf || schema.anyOf)) {
-        return 'combined';
+        const hasProperties = (schema.properties && Object.keys(schema.properties).length > 0) || schema.additionalProperties;
+        return hasProperties ? 'object' : 'combined';
     }
     else if (Array.isArray(schema.type)) {
         return 'multi-type';
@@ -19,9 +21,14 @@ export function determineSchemaKind(schema) {
         schema.type === 'array') {
         return schema.type;
     }
-    return 'unknown';
+    const treadAsObject = ctx.config.unknownTypeBehavior === 'always-object' ||
+        (ctx.config.unknownTypeBehavior === 'object-if-properties' &&
+            schema.properties &&
+            Object.keys(schema.properties).length > 0);
+    return treadAsObject ? 'object' : 'unknown';
 }
 export function determineSchemaName(schema, id) {
+    var _a, _b, _c, _d, _e, _f;
     if (schema.title)
         return { name: schema.title, isGenerated: false };
     if (!schema.$src) {
@@ -34,7 +41,34 @@ export function determineSchemaName(schema, id) {
     const responseMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/responses\/(?<status>\d+)\//);
     if (responseMatch && responseMatch.groups) {
         const { path, method, status } = responseMatch.groups;
-        return { name: `${method}_${path.replace(/\//g, '_')}_${status}_Response`, isGenerated: true };
+        const operation = (_c = (_b = (_a = schema.$src.document.paths) === null || _a === void 0 ? void 0 : _a[path]) === null || _b === void 0 ? void 0 : _b[method]) !== null && _c !== void 0 ? _c : {};
+        return {
+            name: `${determineEndpointName({ method, path: `/${path}`, operation })}_${status}_Response`,
+            isGenerated: true,
+        };
+    }
+    const responseCompMatch = schema.$src.path.match(/\/components\/responses\/([^/]+)\/content\/.+\/schema/);
+    if (responseCompMatch) {
+        return {
+            name: responseCompMatch[1].toLowerCase().endsWith('response')
+                ? responseCompMatch[1]
+                : responseCompMatch[1] + 'Response',
+            isGenerated: true,
+        };
+    }
+    const requestBodyMatch = schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/requestBody\//);
+    if (requestBodyMatch && requestBodyMatch.groups) {
+        const { path, method } = requestBodyMatch.groups;
+        const operation = (_f = (_e = (_d = schema.$src.document.paths) === null || _d === void 0 ? void 0 : _d[path]) === null || _e === void 0 ? void 0 : _e[method]) !== null && _f !== void 0 ? _f : {};
+        return { name: `${determineEndpointName({ method, path: `/${path}`, operation })}_Request`, isGenerated: true };
+    }
+    const parentSchemaMatch = schema.$src.path.match(/(.*)\/properties\/([^/]*)$/);
+    if (parentSchemaMatch) {
+        const parentSchema = getDeepProperty(schema.$src.document, parentSchemaMatch[1].split('/').filter(Boolean));
+        const parentSchemaName = determineSchemaName({ title: parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.title, $src: { path: parentSchemaMatch[1], document: schema.$src.document } }, id);
+        if (!parentSchemaName.isGenerated) {
+            return { name: `${parentSchemaName.name}_${parentSchemaMatch[2]}`, isGenerated: true };
+        }
     }
     return { name: id, isGenerated: true };
 }

package/esm/lib/transform/transform-schema.js

@@ -1,19 +1,19 @@
 import { determineSchemaAccessibility, determineSchemaKind, determineSchemaName, getCustomFields, getOpenApiObjectIdentifier, transformAdditionalProperties, transformSchemaProperties, } from './helpers';
 import { createOverwriteProxy } from '../utils';
-export function transformSchema(context, schema) {
+export function transformSchema(ctx, schema) {
     var _a, _b;
     if (!schema) {
         throw new Error('Schema is required.');
     }
     const schemaSource = `${schema.$src.file}:${schema.$src.path}`;
-    const existingSchema = (_a = context.schemas.get(schemaSource)) !== null && _a !== void 0 ? _a : context.incompleteSchemas.get(schemaSource);
+    const existingSchema = (_a = ctx.schemas.get(schemaSource)) !== null && _a !== void 0 ? _a : ctx.incompleteSchemas.get(schemaSource);
     if (existingSchema)
         return existingSchema;
     const openApiObjectId = getOpenApiObjectIdentifier(schema);
-    const existing = context.transformed.schemas.get(openApiObjectId);
+    const existing = ctx.transformed.schemas.get(openApiObjectId);
     if (existing)
         return existing;
-    let kind = determineSchemaKind(schema);
+    let kind = determineSchemaKind(ctx, schema);
     let nullable = kind === 'null';
     if (kind === 'multi-type') {
         const types = schema.type;
@@ -27,13 +27,13 @@ export function transformSchema(context, schema) {
             const newType = types.filter((t) => t !== 'null' && t !== null)[0];
             schema = createOverwriteProxy(schema);
             schema.type = newType;
-            kind = determineSchemaKind(schema);
+            kind = determineSchemaKind(ctx, schema);
         }
         else {
             schema.type = types.filter((t) => t !== 'null' && t !== null);
         }
     }
-    const id = context.idGenerator.generateId('schema');
+    const id = ctx.idGenerator.generateId('schema');
     const nameInfo = determineSchemaName(schema, id);
     const incompleteSchema = {
         $src: {
@@ -54,7 +54,7 @@ export function transformSchema(context, schema) {
         nullable: nullable || schema.nullable === true,
         required: new Set(schema.required),
         custom: getCustomFields(schema),
-        not: schema.not ? transformSchema(context, schema.not) : undefined,
+        not: schema.not ? transformSchema(ctx, schema.not) : undefined,
         const: schema.const,
         discriminator: schema.discriminator
             ? {
@@ -64,101 +64,117 @@ export function transformSchema(context, schema) {
             : undefined,
         inheritedSchemas: [],
     };
-    context.incompleteSchemas.set(schemaSource, incompleteSchema);
+    ctx.incompleteSchemas.set(schemaSource, incompleteSchema);
     if (schema.$ref) {
-        incompleteSchema.$ref = transformSchema(context, schema.$ref);
+        incompleteSchema.$ref = transformSchema(ctx, schema.$ref);
     }
-    const extensions = schemaTransformers[kind](schema, context);
+    const extensions = schemaTransformers[kind](schema, ctx);
     const completeSchema = Object.assign(incompleteSchema, extensions);
-    resolveDescriminatorMapping(context, completeSchema);
-    context.incompleteSchemas.delete(schemaSource);
-    context.transformed.schemas.set(openApiObjectId, completeSchema);
-    context.schemas.set(schemaSource, completeSchema);
+    resolveDescriminatorMapping(ctx, completeSchema);
+    ctx.incompleteSchemas.delete(schemaSource);
+    ctx.transformed.schemas.set(openApiObjectId, completeSchema);
+    ctx.schemas.set(schemaSource, completeSchema);
     return completeSchema;
 }
-const schemaTransformers = {
-    oneOf: (schema, context) => {
-        var _a, _b;
-        return ({
-            oneOf: (_b = (_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-        });
-    },
-    string: (schema) => ({
-        type: 'string',
+function allExtensionsTransformer(schema, context) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        oneOf: (_b = (_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
         format: schema.format,
         pattern: schema.pattern,
         minLength: schema.minLength,
         maxLength: schema.maxLength,
-    }),
-    number: (schema) => ({
-        type: 'number',
-        format: schema.format,
         minimum: schema.minimum,
         maximum: schema.maximum,
+        properties: transformSchemaProperties(context, schema, transformSchema),
+        additionalProperties: transformAdditionalProperties(context, schema, transformSchema),
+        allOf: (_d = (_c = schema.allOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
+        anyOf: (_f = (_e = schema.anyOf) === null || _e === void 0 ? void 0 : _e.map((s) => transformSchema(context, s))) !== null && _f !== void 0 ? _f : [],
+        items: schema.items ? transformSchema(context, schema.items) : undefined,
+        minItems: schema.minItems,
+        maxItems: schema.maxItems,
+    };
+}
+const schemaTransformers = {
+    oneOf: (schema, context) => ({
+        ...allExtensionsTransformer(schema, context),
+    }),
+    string: (schema, context) => ({
+        type: 'string',
+        ...allExtensionsTransformer(schema, context),
+    }),
+    number: (schema, context) => ({
+        type: 'number',
+        ...allExtensionsTransformer(schema, context),
     }),
-    boolean: (schema) => ({ type: 'boolean', format: schema.format }),
-    object: (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            type: 'object',
-            properties: transformSchemaProperties(context, schema, transformSchema),
-            format: schema.format,
-            additionalProperties: transformAdditionalProperties(context, schema, transformSchema),
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-        });
-    },
-    integer: (schema) => ({
+    boolean: (schema, context) => ({ type: 'boolean', ...allExtensionsTransformer(schema, context) }),
+    object: (schema, context) => ({
+        type: 'object',
+        ...allExtensionsTransformer(schema, context),
+    }),
+    integer: (schema, context) => ({
         type: 'integer',
-        format: schema.format,
-        minimum: schema.minimum,
-        maximum: schema.maximum,
+        ...allExtensionsTransformer(schema, context),
     }),
     array: (schema, context) => ({
         type: 'array',
-        items: schema.items ? transformSchema(context, schema.items) : undefined,
-        minItems: schema.minItems,
-        maxItems: schema.maxItems,
+        ...allExtensionsTransformer(schema, context),
+    }),
+    combined: (schema, context) => ({
+        ...allExtensionsTransformer(schema, context),
+    }),
+    'multi-type': (schema, context) => ({
+        type: schema.type,
+        ...allExtensionsTransformer(schema, context),
     }),
-    combined: (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-        });
-    },
-    'multi-type': (schema, context) => {
-        var _a, _b, _c, _d;
-        return ({
-            type: schema.type,
-            items: schema.items ? transformSchema(context, schema.items) : undefined,
-            minItems: schema.minItems,
-            maxItems: schema.maxItems,
-            minimum: schema.minimum,
-            maximum: schema.maximum,
-            format: schema.format,
-            properties: transformSchemaProperties(context, schema, transformSchema),
-            additionalProperties: transformAdditionalProperties(context, schema, transformSchema),
-            allOf: (_b = (_a = schema.allOf) === null || _a === void 0 ? void 0 : _a.map((s) => transformSchema(context, s))) !== null && _b !== void 0 ? _b : [],
-            anyOf: (_d = (_c = schema.anyOf) === null || _c === void 0 ? void 0 : _c.map((s) => transformSchema(context, s))) !== null && _d !== void 0 ? _d : [],
-            maxLength: schema.maxLength,
-            minLength: schema.minLength,
-            pattern: schema.pattern,
-        });
-    },
     null: () => ({ type: 'null' }),
     unknown: () => ({}),
 };
 function resolveDescriminatorMapping(context, schema) {
     const discriminator = schema.$src.component.discriminator;
-    if (!discriminator || typeof discriminator === 'string' || !discriminator.mapping)
-        return;
-    for (const key of Object.keys(discriminator.mapping)) {
-        const mappedSchemaRef = discriminator.mapping[key];
-        const mappedSchema = transformSchema(context, mappedSchemaRef);
-        if (schema.discriminator) {
-            schema.discriminator.mapping[key] = mappedSchema;
-            mappedSchema.inheritedSchemas.push(schema);
+    if (discriminator && typeof discriminator === 'object' && discriminator.mapping) {
+        for (const key of Object.keys(discriminator.mapping)) {
+            const mappedSchemaRef = discriminator.mapping[key];
+            const mappedSchema = transformSchema(context, mappedSchemaRef);
+            if (schema.discriminator) {
+                schema.discriminator.mapping[key] = mappedSchema;
+                const hasInheritedSchema = mappedSchema.inheritedSchemas.some((x) => x.id === schema.id);
+                if (!hasInheritedSchema) {
+                    mappedSchema.inheritedSchemas.push(schema);
+                }
+            }
         }
     }
+    if (schema.kind === 'combined' && schema.allOf) {
+        for (const s of schema.allOf) {
+            const base = findDiscriminatedSchema(s);
+            if (!base)
+                continue;
+            if (base.discriminator && base.discriminator.propertyName) {
+                const origDiscriminator = base.$src.component.discriminator;
+                if (origDiscriminator &&
+                    typeof origDiscriminator === 'object' &&
+                    origDiscriminator.mapping &&
+                    Object.values(origDiscriminator.mapping).some((x) => x.$src.file === schema.$src.file && x.$src.path === schema.$src.path)) {
+                    continue;
+                }
+                const mappingKey = schema.isNameGenerated ? null : schema.name;
+                if (!mappingKey) {
+                    continue;
+                }
+                base.discriminator.mapping[mappingKey] = schema;
+                const hasInheritedSchema = schema.inheritedSchemas.some((x) => x.id === base.id);
+                if (!hasInheritedSchema) {
+                    schema.inheritedSchemas.push(base);
+                }
+            }
+        }
+    }
+}
+function findDiscriminatedSchema(schema) {
+    const origDiscriminator = schema.$src.originalComponent.discriminator;
+    if (origDiscriminator && (typeof origDiscriminator === 'string' || origDiscriminator.propertyName)) {
+        return schema;
+    }
+    return schema.$ref ? findDiscriminatedSchema(schema.$ref) : null;
 }

package/esm/lib/transform/transformer.js

@@ -2,8 +2,10 @@ import { IdGenerator } from './helpers';
 import { transformDocument } from './transform-document';
 import { transformEndpoint } from './transform-endpoint';
 import { transformSchema } from './transform-schema';
-export function transformOpenApi(data) {
+import { defaultOpenApiTransformerOptions } from './types';
+export function transformOpenApi(data, options) {
     const context = {
+        config: { ...defaultOpenApiTransformerOptions, ...options },
         idGenerator: new IdGenerator(),
         input: data,
         incompleteSchemas: new Map(),

package/esm/lib/transform/types.js

@@ -1 +1,3 @@
-export {};
+export const defaultOpenApiTransformerOptions = {
+    unknownTypeBehavior: 'object-if-properties',
+};

package/esm/lib/utils/object.utils.js

@@ -5,6 +5,16 @@ export function createOverwriteProxy(target, values) {
     }
     return proxy;
 }
+export function getDeepProperty(obj, path) {
+    let current = obj;
+    for (const key of path) {
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
 class OverwriteProxyHandler {
     constructor() {
         this._overwrittenValues = {};

package/esm/lib/utils/schema.utils.js

@@ -5,6 +5,9 @@ export function resolveAnyOfAndAllOf(schema, ignoreNonObjectParts) {
     }
     const required = new Set(schema.required);
     const properties = new Map();
+    if ('properties' in schema) {
+        schema.properties.forEach((prop) => properties.set(prop.name, prop));
+    }
     collectSubSchemaProperties(schema.allOf, properties, required, false);
     collectSubSchemaProperties(schema.anyOf, properties, required, true);
     const initialAdditionalProperties = schema.kind === 'object' ? schema.additionalProperties : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/core",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "repository": "https://github.com/MaSch0212/goast.git",
   "description": "A tool designed to transform OpenAPI specifications into various forms with flexibility and extensibility at its core.",
   "keywords": [

package/types/lib/codegen/config.d.ts

@@ -1,5 +1,6 @@
+import { OpenApiParserOptions } from '../parse';
 import { SourceBuilderOptions } from '../utils/source-builder';
-export type OpenApiGeneratorConfig = SourceBuilderOptions & {
+export type OpenApiGeneratorConfig = SourceBuilderOptions & OpenApiParserOptions & {
     /**
      * The directory where the generated files should be saved.
      * @default 'generated'

package/types/lib/codegen/generator.d.ts

@@ -27,6 +27,7 @@ declare class _OpenApiGenerator<TOutput extends OpenApiGeneratorInput> {
 }
 export declare class OpenApiGenerator extends _OpenApiGenerator<{}> {
     constructor(config?: Partial<OpenApiGeneratorConfig>);
+    private static getCtorArgs;
 }
 export type DefaultGenerationProviderConfig<T extends AnyConfig> = Omit<T, keyof OpenApiGeneratorConfig> & Partial<Pick<T, keyof OpenApiGeneratorConfig>>;
 export declare abstract class OpenApiGenerationProviderBase<TInput extends OpenApiGeneratorInput, TOutput extends OpenApiGeneratorOutput, TConfig extends AnyConfig, TContext extends OpenApiGenerationProviderContext<TInput, TConfig>> implements OpenApiGenerationProvider<TInput, TOutput, TConfig> {

package/types/lib/parse/parser.d.ts

@@ -1,8 +1,10 @@
 import { OpenApiDocument } from './openapi-types';
-import { Deref } from './types';
+import { Deref, OpenApiParserOptions } from './types';
 import { ApiData } from '../transform';
 export declare class OpenApiParser {
     private readonly _loadedDocuments;
+    private readonly _config;
+    constructor(config?: Partial<OpenApiParserOptions>);
     parseApisAndTransform(...fileNames: (string | string[])[]): Promise<ApiData>;
     parseApi(fileName: string): Promise<Deref<OpenApiDocument>>;
     transformApis(apis: Deref<OpenApiDocument>[]): ApiData;

package/types/lib/parse/types.d.ts

@@ -1,4 +1,5 @@
 import { OpenApiDiscriminator, OpenApiDocument, OpenApiReference, OpenApiSchema } from './openapi-types';
+import { OpenApiTransformerOptions } from '../transform/types';
 export type DerefSource<T> = {
     file: string;
     path: string;
@@ -15,4 +16,8 @@ type _Deref<T extends object> = T extends OpenApiDiscriminator ? _DerefDiscrimin
     $ref?: Deref<T>;
 };
 export type Deref<T> = T extends object ? (T extends (infer A)[] ? Deref<A>[] : _Deref<T>) : T;
+export type OpenApiParserOptions = OpenApiTransformerOptions;
+export declare const defaultOpenApiParserOptions: {
+    unknownTypeBehavior: "keep-unknown" | "object-if-properties" | "always-object";
+};
 export {};

package/types/lib/transform/helpers.d.ts

@@ -1,16 +1,19 @@
 import { ApiSchemaKind, ApiSchemaAccessibility, ApiSchema, ApiSchemaProperty } from './api-types';
 import { OpenApiTransformerContext } from './types';
-import { Deref, OpenApiObject } from '../parse';
+import { Deref, OpenApiDocument, OpenApiObject } from '../parse';
 export declare function determineSchemaKind<T extends {
     oneOf?: unknown;
     allOf?: unknown;
     anyOf?: unknown;
     type?: string | string[];
-}>(schema: T): ApiSchemaKind;
+    properties?: Record<string, unknown>;
+    additionalProperties?: unknown;
+}>(ctx: OpenApiTransformerContext, schema: T): ApiSchemaKind;
 export declare function determineSchemaName(schema: {
     title?: string;
     $src: {
         path: string;
+        document: Deref<OpenApiDocument>;
     };
 }, id: string): {
     name: string;

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

@@ -1,4 +1,4 @@
 import { ApiSchema } from './api-types';
 import { OpenApiTransformerContext } from './types';
 import { Deref, OpenApiSchema } from '../parse';
-export declare function transformSchema<T extends Deref<OpenApiSchema>>(context: OpenApiTransformerContext, schema: T): ApiSchema;
+export declare function transformSchema<T extends Deref<OpenApiSchema>>(ctx: OpenApiTransformerContext, schema: T): ApiSchema;

package/types/lib/transform/transformer.d.ts

@@ -1,3 +1,4 @@
 import { ApiData } from './api-types';
+import { OpenApiTransformerOptions } from './types';
 import { OpenApiCollectorData } from '../collect';
-export declare function transformOpenApi(data: OpenApiCollectorData): ApiData;
+export declare function transformOpenApi(data: OpenApiCollectorData, options?: Partial<OpenApiTransformerOptions>): ApiData;

package/types/lib/transform/types.d.ts

@@ -2,8 +2,20 @@ import { ApiSchema, ApiSchemaExtensions, ApiSchemaKind, ApiPath, ApiData, ApiSer
 import { IdGenerator } from './helpers';
 import { OpenApiCollectorData } from '../collect/types';
 import { ArrayItem } from '../utils/type.utils';
+export type OpenApiTransformerOptions = {
+    /**
+     * Determines how schemas without a `type` property should be treated.
+     * - `keep-unknown`: Keep the schema as-is.
+     * - `object-if-properties`: Treat the schema as an object schema only if it has properties.
+     * - `always-object`: Treat the schema as an object schema.
+     * @default 'object-if-properties'
+     */
+    unknownTypeBehavior: 'keep-unknown' | 'object-if-properties' | 'always-object';
+};
+export declare const defaultOpenApiTransformerOptions: OpenApiTransformerOptions;
 export type IncompleteApiSchema = Omit<ApiSchema, Exclude<keyof ApiSchemaExtensions<ApiSchemaKind>, 'kind'>>;
 export type OpenApiTransformerContext = {
+    config: OpenApiTransformerOptions;
     idGenerator: IdGenerator;
     input: OpenApiCollectorData;
     incompleteSchemas: Map<string, IncompleteApiSchema>;

package/types/lib/utils/object.utils.d.ts

@@ -1 +1,2 @@
 export declare function createOverwriteProxy<T extends object>(target: T, values?: Partial<T>): T;
+export declare function getDeepProperty(obj: object, path: string[]): unknown;