@weclapp/sdk 2.0.0-dev.50 → 2.0.0-dev.51

package/dist/cli.js

@@ -4,7 +4,7 @@ import { rollup } from 'rollup';
 import terser from '@rollup/plugin-terser';
 import ts from '@rollup/plugin-typescript';
 import indentString from 'indent-string';
-import { snakeCase, camelCase, pascalCase } from 'change-case';
+import { snakeCase, pascalCase, camelCase } from 'change-case';
 import chalk from 'chalk';
 import { OpenAPIV3 } from 'openapi-types';
 import { createHash } from 'crypto';
@@ -157,8 +157,8 @@ const resolveImports = (target) => {
 };
 const resolveMappings = (target) => `const wrapResponse = ${isRXTarget(target) ? 'defer' : '(v: (...args: any[]) => any) => v()'};`;
 const resolveBinaryClass = (target) => `const resolveBinaryObject = () => ${resolveBinaryType(target)};`;
-const generateBase = (target, apiVersion, options) => {
-    return generateStatements(resolveImports(target), `const apiVersion = ${apiVersion}`, resolveMappings(target), resolveBinaryClass(target), globalConfig, types, utils, root, options.useQueryLanguage ? queriesWithQueryLanguage : queriesWithFilter, options.generateUnique ? unique : '', multiRequest);
+const generateBase = (apiVersion, { target, useQueryLanguage, generateUnique }) => {
+    return generateStatements(resolveImports(target), `const apiVersion = ${apiVersion}`, resolveMappings(target), resolveBinaryClass(target), globalConfig, types, utils, root, useQueryLanguage ? queriesWithQueryLanguage : queriesWithFilter, generateUnique ? unique : '', multiRequest);
 };
 
 const transformKey = (s) => snakeCase(s).toUpperCase();
@@ -191,22 +191,10 @@ const isArraySchemaObject = (v) => {
 const isResponseObject = (v) => {
     return isObject(v) && typeof v.description === 'string';
 };
-const isNonArraySchemaObject = (v) => {
-    return isObject(v) && ['string', 'undefined'].includes(typeof v.type);
-};
-const isFilterPathsSchemaObject = (v) => {
-    return isObject(v) && v.type === 'object' && isObject(v['x-weclapp-filterPaths']);
-};
-const isFilterPropertySchemaObject = (v) => {
-    return isObject(v) && v.type === 'object' && isObject(v['x-weclapp-filterProperties']);
-};
-const isRelatedEntitySchema = (v) => {
-    return isObject(v) && isNonArraySchemaObject(v) && 'x-weclapp' in v && isObject(v['x-weclapp']);
-};
 
-const generateEnums = (schemas) => {
+const generateEnums = (context) => {
     const enums = new Map();
-    for (const [schemaName, schema] of schemas) {
+    for (const [schemaName, schema] of context.schemas) {
         if (isEnumSchemaObject(schema)) {
             const enumName = loosePascalCase(schemaName);
             if (!enums.has(enumName)) {
@@ -232,6 +220,23 @@ const concat = (strings, separator = ', ', maxLength = 80) => {
     }
 };
 
+const convertParametersToSchemaObject = (parameters) => {
+    const properties = [];
+    const required = [];
+    for (const param of parameters) {
+        if (param.in === 'query' && param.schema) {
+            properties.push([param.name, param.schema]);
+            if (param.required)
+                required.push(param.name);
+        }
+    }
+    return {
+        type: 'object',
+        properties: Object.fromEntries(properties),
+        required
+    };
+};
+
 const createReferenceType = (value) => ({
     type: 'reference',
     toString: () => loosePascalCase(value)
@@ -274,7 +279,10 @@ const getRefName = (obj) => {
     return obj.$ref.replace(/.*\//, '');
 };
 const convertToTypeScriptType = (schema) => {
-    if (isReferenceObject(schema)) {
+    if (Array.isArray(schema)) {
+        return convertToTypeScriptType(convertParametersToSchemaObject(schema));
+    }
+    else if (isReferenceObject(schema)) {
         return createReferenceType(getRefName(schema));
     }
     else {
@@ -293,7 +301,7 @@ const convertToTypeScriptType = (schema) => {
                 return createRawType('boolean');
             case 'object': {
                 const { properties = {}, required = [] } = schema;
-                return createObjectType(Object.fromEntries(Object.entries(properties).map((v) => [v[0], convertToTypeScriptType(v[1])])), required);
+                return createObjectType(Object.fromEntries(Object.entries(properties).map(([prop, propSchema]) => [prop, convertToTypeScriptType(propSchema)])), required);
             }
             case 'array':
                 return createArrayType(convertToTypeScriptType(schema.items));
@@ -303,40 +311,43 @@ const convertToTypeScriptType = (schema) => {
     }
 };
 
-const setEntityEnumProperty = (enums, prop, meta) => {
+const setReferenceMeta = (prop, metaData, context) => {
     const referenceName = getRefName(prop);
-    const enumName = loosePascalCase(referenceName);
-    if (enums.has(enumName)) {
-        meta.enum = enumName;
+    const referenceSchema = context.schemas.get(referenceName);
+    if (isEnumSchemaObject(referenceSchema)) {
+        metaData.enum = loosePascalCase(referenceName);
     }
     else {
-        meta.entity = referenceName;
+        metaData.entity = referenceName;
     }
 };
-const extractPropertyMetaData = (enums, meta, prop) => {
-    const result = {
-        service: meta.service,
-        entity: meta.entity
-    };
+const extractPropertyMetaData = (prop, context) => {
+    const metaData = {};
+    const weclappExtension = prop['x-weclapp'];
+    if (weclappExtension) {
+        metaData.service = weclappExtension.service;
+        metaData.entity = weclappExtension.entity;
+    }
     if (isReferenceObject(prop)) {
-        setEntityEnumProperty(enums, prop, result);
-        result.type = 'reference';
-        return result;
-    }
-    result.type = prop.type;
-    result.format = prop.format;
-    result.maxLength = prop.maxLength;
-    result.pattern = prop.pattern;
-    if (isArraySchemaObject(prop)) {
-        if (isReferenceObject(prop.items)) {
-            setEntityEnumProperty(enums, prop.items, result);
-            result.format = 'reference';
-        }
-        else {
-            result.format = 'string';
+        metaData.type = 'reference';
+        setReferenceMeta(prop, metaData, context);
+    }
+    else {
+        metaData.type = prop.type;
+        metaData.format = prop.format;
+        metaData.maxLength = prop.maxLength;
+        metaData.pattern = prop.pattern;
+        if (isArraySchemaObject(prop)) {
+            if (isReferenceObject(prop.items)) {
+                metaData.format = 'reference';
+                setReferenceMeta(prop.items, metaData, context);
+            }
+            else {
+                metaData.format = 'string';
+            }
         }
     }
-    return result;
+    return metaData;
 };
 
 const generateInlineComment = (comment) => `/** ${comment} */`;
@@ -383,108 +394,6 @@ const generateInterfaceType = (name, entries, extend) => {
     return generateType(name, typeDefinition);
 };
 
-const FILTER_PROPS_SUFFIX = 'Filter_Props';
-const generateEntities = (schemas, enums) => {
-    const entities = new Map();
-    for (const [schemaName, schema] of schemas) {
-        // Enums are generated separately
-        if (isEnumSchemaObject(schema)) {
-            continue;
-        }
-        const entityInterfaceName = loosePascalCase(schemaName);
-        let parentEntityInterfaceName = undefined;
-        const entityInterfaceProperties = [];
-        const filterableInterfaceProperties = [];
-        const properties = new Map();
-        const processProperties = (props = {}, isXweclappFilterProp) => {
-            for (const [name, property] of Object.entries(props)) {
-                const meta = isRelatedEntitySchema(property) ? property['x-weclapp'] : {};
-                const type = convertToTypeScriptType(property).toString();
-                const comment = isNonArraySchemaObject(property)
-                    ? property.deprecated
-                        ? '@deprecated will be removed.'
-                        : property.format
-                            ? `format: ${property.format}`
-                            : undefined
-                    : undefined;
-                if (meta.filterable !== false) {
-                    filterableInterfaceProperties.push({ name, type });
-                }
-                if (!isXweclappFilterProp) {
-                    entityInterfaceProperties.push({
-                        name,
-                        type,
-                        comment,
-                        required: meta.required,
-                        filterable: meta.filterable ?? true,
-                        readonly: !isReferenceObject(property) && property.readOnly
-                    });
-                    properties.set(name, extractPropertyMetaData(enums, meta, property));
-                }
-            }
-        };
-        if (schema.allOf?.length) {
-            for (const item of schema.allOf) {
-                if (isReferenceObject(item)) {
-                    parentEntityInterfaceName = convertToTypeScriptType(item).toString();
-                }
-                else if (isObjectSchemaObject(item)) {
-                    processProperties(item.properties);
-                    if (isFilterPropertySchemaObject(item)) {
-                        processProperties(item['x-weclapp-filterProperties'], true);
-                    }
-                    if (isFilterPathsSchemaObject(item)) {
-                        const fPaths = item['x-weclapp-filterPaths'];
-                        for (const path in fPaths) {
-                            if (!path.includes('.')) {
-                                filterableInterfaceProperties.push({ name: path, type: fPaths[path] });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        processProperties(schema.properties);
-        entities.set(schemaName, {
-            name: schemaName,
-            properties,
-            filterableInterfaceProperties: filterableInterfaceProperties.sort((propA, propB) => propA.name.localeCompare(propB.name)),
-            parentName: parentEntityInterfaceName ? camelCase(parentEntityInterfaceName) : undefined,
-            source: generateStatements(generateInterface(entityInterfaceName, entityInterfaceProperties, parentEntityInterfaceName))
-        });
-    }
-    return entities;
-};
-const generateEntityFilterProps = (entities, enums) => {
-    const entityFilterProps = new Map();
-    const transformFilterProps = (props) => {
-        return props.map((prop) => {
-            if (!prop.type ||
-                enums.has(prop.type) ||
-                prop.type === 'string' ||
-                prop.type === 'number' ||
-                prop.type === 'boolean' ||
-                prop.type === '{}' ||
-                prop.type.endsWith('[]') ||
-                prop.type.includes("'")) {
-                return prop;
-            }
-            return { ...prop, type: `${pascalCase(prop.type)}_${FILTER_PROPS_SUFFIX}` };
-        });
-    };
-    entities.forEach((entity, name) => {
-        const entityFilterName = `${pascalCase(name)}_${FILTER_PROPS_SUFFIX}`;
-        const parentName = entity.parentName ? `${pascalCase(entity.parentName)}_${FILTER_PROPS_SUFFIX}` : undefined;
-        const filterableInterfaceProperties = transformFilterProps(entity.filterableInterfaceProperties);
-        entityFilterProps.set(entityFilterName, {
-            name: entityFilterName,
-            parentName,
-            source: generateStatements(generateInterface(entityFilterName, filterableInterfaceProperties, parentName))
-        });
-    });
-    return entityFilterProps;
-};
-
 /**
  * Pluralizes a word, most of the time correct.
  * @param s String to pluralize.
@@ -554,6 +463,108 @@ const logger = new (class {
     }
 })();
 
+const FILTER_PROPS_SUFFIX = 'Filter_Props';
+const generateEntities = (context) => {
+    const entities = new Map();
+    for (const [schemaName, schema] of context.schemas) {
+        // Enums are generated separately
+        if (isEnumSchemaObject(schema)) {
+            continue;
+        }
+        const entityName = schemaName;
+        const entityInterfaceName = loosePascalCase(entityName);
+        const entityInterfaceProperties = [];
+        const properties = new Map();
+        let parentEntityName = undefined;
+        let parentEntityInterfaceName = undefined;
+        const entityFilterInterfaceName = `${entityInterfaceName}_${FILTER_PROPS_SUFFIX}`;
+        const entityFilterInterfaceProperties = [];
+        let parentEntityFilterInterfaceName = undefined;
+        const processProperties = (props = {}) => {
+            for (const [propertyName, propertySchema] of Object.entries(props)) {
+                const weclappExtension = propertySchema['x-weclapp'];
+                properties.set(propertyName, extractPropertyMetaData(propertySchema, context));
+                const type = convertToTypeScriptType(propertySchema).toString();
+                // cast to SchemaObject to access deprecated and readOnly properties (ReferenceObject can also include these props in OpenAPI 3.1)
+                const castedSchema = propertySchema;
+                const comment = castedSchema.deprecated
+                    ? '@deprecated will be removed.'
+                    : castedSchema.format
+                        ? `format: ${castedSchema.format}`
+                        : undefined;
+                if (weclappExtension?.filterable !== false) {
+                    entityFilterInterfaceProperties.push({ name: propertyName, type, comment });
+                }
+                entityInterfaceProperties.push({
+                    name: propertyName,
+                    type,
+                    required: weclappExtension?.required,
+                    readonly: castedSchema.readOnly,
+                    comment
+                });
+            }
+        };
+        const processExtraFilterProperties = (props = {}) => {
+            for (const [propertyName, propertySchema] of Object.entries(props)) {
+                if (isReferenceObject(propertySchema))
+                    continue;
+                const type = convertToTypeScriptType(propertySchema).toString();
+                const comment = propertySchema.deprecated
+                    ? '@deprecated will be removed.'
+                    : propertySchema.format
+                        ? `format: ${propertySchema.format}`
+                        : undefined;
+                entityFilterInterfaceProperties.push({ name: propertyName, type, comment });
+            }
+        };
+        const processFilterPaths = (filterPaths = {}) => {
+            for (const [filterProp, entityName] of Object.entries(filterPaths)) {
+                if (!filterProp.includes('.') && context.schemas.get(entityName)) {
+                    entityFilterInterfaceProperties.push({
+                        name: filterProp,
+                        type: `${loosePascalCase(entityName)}_${FILTER_PROPS_SUFFIX}`
+                    });
+                }
+            }
+        };
+        if (schema.allOf?.length) {
+            if (schema.allOf.length > 2) {
+                logger.errorLn(`Failed to process schema for ${schemaName}: invalid allOf length`);
+                continue;
+            }
+            for (const item of schema.allOf) {
+                if (isReferenceObject(item)) {
+                    parentEntityName = getRefName(item);
+                    parentEntityInterfaceName = createReferenceType(parentEntityName).toString();
+                    parentEntityFilterInterfaceName = `${parentEntityInterfaceName}_${FILTER_PROPS_SUFFIX}`;
+                }
+                else if (item.type === 'object') {
+                    processProperties(item.properties);
+                    processExtraFilterProperties(item['x-weclapp-filterProperties']);
+                    processFilterPaths(item['x-weclapp-filterPaths']);
+                }
+                else {
+                    logger.errorLn(`Failed to process schema for ${schemaName}: invalid schema type in allOf`);
+                }
+            }
+        }
+        else {
+            processProperties(schema.properties);
+        }
+        entities.set(entityName, {
+            name: entityName,
+            interfaceName: entityInterfaceName,
+            properties,
+            source: generateStatements(generateInterface(entityInterfaceName, entityInterfaceProperties, parentEntityInterfaceName)),
+            filterInterfaceName: entityFilterInterfaceName,
+            filterSource: generateStatements(generateInterface(entityFilterInterfaceName, entityFilterInterfaceProperties, parentEntityFilterInterfaceName)),
+            parentName: parentEntityName,
+            parentInterfaceName: parentEntityInterfaceName
+        });
+    }
+    return entities;
+};
+
 /**
  * ROOT => /article
  * COUNT => /article/count
@@ -600,6 +611,31 @@ const parseEndpointPath = (path) => {
     }
     return undefined;
 };
+const isMultiPartUploadPath = (path) => {
+    const [, entity, ...rest] = path.split('/');
+    return entity && rest.length === 2 && rest[1] === 'multipartUpload';
+};
+const parseEndpointsPaths = (paths) => {
+    const endpoints = new Map();
+    for (const [rawPath, path] of Object.entries(paths)) {
+        const endpoint = parseEndpointPath(rawPath);
+        if (!endpoint || !path) {
+            // Todo: Should be removed if sdk supports multi part upload.
+            if (isMultiPartUploadPath(rawPath)) {
+                continue;
+            }
+            logger.errorLn(`Failed to parse ${rawPath}`);
+            continue;
+        }
+        if (endpoints.has(endpoint.service)) {
+            endpoints.get(endpoint.service)?.push({ endpoint, path });
+        }
+        else {
+            endpoints.set(endpoint.service, [{ endpoint, path }]);
+        }
+    }
+    return endpoints;
+};
 
 const generateArrowFunction = ({ name, signature, returns, params }) => {
     return `const ${name}: ${signature} = (${params?.join(', ') ?? ''}) =>\n${indent(returns)};`;
@@ -611,43 +647,40 @@ const generateArrowFunctionType = ({ type, returns = 'void', generics, params })
     return generateType(type, `${genericsString + paramsString} =>\n${indent(returns)}`);
 };
 
-const convertParametersToSchema = (parameters = []) => {
-    const properties = [];
-    const required = [];
-    for (const param of parameters) {
-        if (isParameterObject(param) && param.in === 'query') {
-            if (param.schema) {
-                properties.push([param.name, param.schema]);
-                if (param.required)
-                    required.push(param.name);
-            }
+const resolveParameters = (resolvableParameters = [], parameters) => {
+    if (!resolvableParameters)
+        return [];
+    return resolvableParameters.flatMap((param) => {
+        if (isReferenceObject(param)) {
+            const resolved = parameters.get(getRefName(param));
+            return resolved ? [resolved] : [];
         }
-    }
-    return {
-        type: 'object',
-        required,
-        properties: Object.fromEntries(properties)
-    };
+        return [param];
+    });
 };
 
-const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
+const generateCountEndpoint = ({ endpoint, operationObject, entities, context, options }) => {
     const functionName = 'count';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
-    const entity = aliases.get(endpoint.service) ?? pascalCase(endpoint.service);
+    const relatedEntityName = context.aliases.get(endpoint.service);
+    const relatedEntity = !!relatedEntityName && entities.get(relatedEntityName);
+    if (!relatedEntity) {
+        throw Error(`Related entity schema for service ${endpoint.service} not found`);
+    }
     const parametersTypeName = `${functionTypeName}_Parameters`;
     const parametersType = createObjectType({
-        params: convertToTypeScriptType(convertParametersToSchema(path.parameters))
+        params: convertToTypeScriptType(resolveParameters(operationObject.parameters, context.parameters))
     });
     const parametersTypeSource = generateInterfaceFromObject(parametersTypeName, parametersType, 'propagate');
     const filterTypeName = `${functionTypeName}_Filter`;
-    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${entity}_${FILTER_PROPS_SUFFIX}`]);
+    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${relatedEntity.filterInterfaceName}`]);
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: [
-            `query${parametersType.isFullyOptional() ? '?' : ''}: CountQuery<${filterTypeName}>${path.parameters?.length ? ' & ' + parametersTypeName : ''}`,
+            `query${parametersType.isFullyOptional() ? '?' : ''}: CountQuery<${filterTypeName}>${operationObject.parameters?.length ? ' & ' + parametersTypeName : ''}`,
             'requestOptions?: RequestOptions'
         ],
-        returns: `${resolveResponseType(target)}<number>`
+        returns: `${resolveResponseType(options.target)}<number>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -656,44 +689,51 @@ const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
         params: ['query', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource },
         interfaces: [
-            ...(path.parameters?.length ? [{ name: parametersTypeName, source: parametersTypeSource }] : []),
+            ...(operationObject.parameters?.length ? [{ name: parametersTypeName, source: parametersTypeSource }] : []),
             { name: filterTypeName, source: filterTypeSource }
         ]
     };
 };
 
-const generateBodyType = (body) => {
-    if (isReferenceObject(body)) {
-        return convertToTypeScriptType(body);
-    }
+const generateContentType = (body, fallback = 'unknown') => {
+    if (!body?.content)
+        return createRawType(fallback);
     const types = [];
-    for (const { schema } of Object.values(body?.content ?? {})) {
+    for (const { schema } of Object.values(body.content)) {
         if (schema) {
             types.push(convertToTypeScriptType(schema));
         }
     }
-    return types.length ? (types.length === 1 ? types[0] : createTupleType(types)) : undefined;
+    return (types.length > 1 ? createTupleType(types) : types[0]) ?? createRawType(fallback);
 };
 
-const generateRequestBodyType = ({ requestBody }) => {
-    return generateBodyType(requestBody) ?? createRawType('unknown');
+const generateRequestBodyType = ({ requestBody }, requestBodies) => {
+    const requestBodyObject = requestBody && isReferenceObject(requestBody) ? requestBodies.get(getRefName(requestBody)) : requestBody;
+    return generateContentType(requestBodyObject);
 };
 
-const resolveBodyType = ({ responses }) => Object.entries(responses).filter((v) => v[0].startsWith('2'))[0]?.[1];
-const generateResponseBodyType = (object) => generateBodyType(resolveBodyType(object)) ?? createRawType('void');
+const resolveResponsesObject = (responses) => Object.entries(responses).find(([statusCode]) => statusCode.startsWith('2'))?.[1];
+
+const generateResponseType = (operationObject, responses) => {
+    const response = resolveResponsesObject(operationObject.responses);
+    const responseObject = response && isReferenceObject(response) ? responses.get(getRefName(response)) : response;
+    return generateContentType(responseObject, 'void');
+};
 
-const generateCreateEndpoint = ({ target, path, endpoint }) => {
+const generateCreateEndpoint = ({ endpoint, operationObject, context, options }) => {
     const functionName = 'create';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
-        params: [`data: DeepPartial<${generateRequestBodyType(path).toString()}>`, 'requestOptions?: RequestOptions'],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+        params: [
+            `data: DeepPartial<${generateRequestBodyType(operationObject, context.requestBodies).toString()}>`,
+            'requestOptions?: RequestOptions'
+        ],
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -702,7 +742,6 @@ const generateCreateEndpoint = ({ target, path, endpoint }) => {
         params: ['data', 'requestOptions?: RequestOptions']
     });
     return {
-        entity: pascalCase(endpoint.service),
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource }
@@ -720,16 +759,19 @@ const insertPathPlaceholder = (path, record) => {
 const wrapBody = (type, target) => {
     return type.toString() === 'binary' ? createRawType(isNodeTarget(target) ? 'BodyInit' : 'Blob') : type; // node-fetch returns a Blob as well
 };
-const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint }) => {
+const generateGenericEndpoint = (suffix) => ({ method, endpoint, operationObject, context, options }) => {
     const functionName = generateGenericFunctionName(endpoint.path, suffix, method);
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
     const entityQuery = `${functionTypeName}_Query`;
     const hasId = endpoint.path.includes('{id}');
     const params = createObjectType({
-        params: convertToTypeScriptType(convertParametersToSchema(path.parameters)),
-        body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path), target)
+        params: operationObject.parameters &&
+            convertToTypeScriptType(resolveParameters(operationObject.parameters, context.parameters)),
+        body: method === 'get'
+            ? undefined
+            : wrapBody(generateRequestBodyType(operationObject, context.requestBodies), options.target)
     });
-    const responseBody = generateResponseBodyType(path);
+    const responseBody = generateResponseType(operationObject, context.responses);
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: [
@@ -737,7 +779,7 @@ const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint })
             `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`,
             'requestOptions?: RequestOptions'
         ],
-        returns: `${resolveResponseType(target)}<${wrapBody(responseBody, target).toString('force')}>`
+        returns: `${resolveResponseType(options.target)}<${wrapBody(responseBody, options.target).toString('force')}>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -746,7 +788,6 @@ const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint })
         returns: `_generic(cfg, ${generateString(method.toUpperCase())}, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, ${String(responseBody.toString() === 'binary')}, requestOptions)`
     });
     return {
-        entity: pascalCase(endpoint.service),
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource },
@@ -759,13 +800,13 @@ const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint })
     };
 };
 
-const generateRemoveEndpoint = ({ target, endpoint }) => {
+const generateRemoveEndpoint = ({ endpoint, options }) => {
     const functionName = 'remove';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: ['id: string', 'options?: RemoveQuery', 'requestOptions?: RequestOptions'],
-        returns: `${resolveResponseType(target)}<void>`
+        returns: `${resolveResponseType(options.target)}<void>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -774,7 +815,6 @@ const generateRemoveEndpoint = ({ target, endpoint }) => {
         params: ['id', 'options?: RemoveQuery', 'requestOptions?: RequestOptions']
     });
     return {
-        entity: pascalCase(endpoint.service),
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource }
@@ -790,8 +830,8 @@ const excludedParameters = [
     'includeReferencedEntities',
     'additionalProperties'
 ];
-const resolveAdditionalPropertiesSchema = (path) => {
-    const body = resolveBodyType(path);
+const resolveAdditionalPropertiesSchema = ({ responses }) => {
+    const body = resolveResponsesObject(responses);
     if (isResponseObject(body)) {
         const schema = body?.content?.['application/json']?.schema;
         if (isObjectSchemaObject(schema)) {
@@ -827,12 +867,14 @@ const resolveReferencedEntities = (entity, entities) => {
     const generatedEntity = entities.get(entity);
     if (generatedEntity) {
         for (const [, propertyMetaData] of generatedEntity.properties) {
-            if (propertyMetaData.entity && propertyMetaData.service) {
-                referencedEntities.push({
-                    name: propertyMetaData.service,
-                    type: `${pascalCase(propertyMetaData.entity)}[]`,
-                    required: true
-                });
+            if (propertyMetaData.service && propertyMetaData.entity) {
+                const referencedEntity = entities.get(propertyMetaData.entity);
+                if (referencedEntity)
+                    referencedEntities.push({
+                        name: propertyMetaData.service,
+                        type: `${referencedEntity.interfaceName}[]`,
+                        required: true
+                    });
             }
         }
         if (generatedEntity.parentName) {
@@ -841,33 +883,37 @@ const resolveReferencedEntities = (entity, entities) => {
     }
     return referencedEntities;
 };
-const generateSomeEndpoint = ({ endpoint, target, path, entities, aliases }) => {
+const generateSomeEndpoint = ({ endpoint, operationObject, entities, context, options }) => {
     const functionName = 'some';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
-    const entity = aliases.get(endpoint.service) ?? pascalCase(endpoint.service);
+    const relatedEntityName = context.aliases.get(endpoint.service);
+    const relatedEntity = !!relatedEntityName && entities.get(relatedEntityName);
+    if (!relatedEntity) {
+        throw Error(`Related entity schema for service ${endpoint.service} not found`);
+    }
     const parametersTypeName = `${functionTypeName}_Parameters`;
-    const parameters = path.parameters?.filter((v) => (isParameterObject(v) ? !excludedParameters.includes(v.name) : false)) ?? [];
+    const parameters = operationObject.parameters?.filter((v) => isParameterObject(v) ? !excludedParameters.includes(v.name) : false);
     const parametersType = createObjectType({
-        params: convertToTypeScriptType(convertParametersToSchema(parameters))
+        params: parameters && convertToTypeScriptType(resolveParameters(parameters, context.parameters))
     });
     const parametersTypeSource = generateInterfaceFromObject(parametersTypeName, parametersType, 'propagate');
     const filterTypeName = `${functionTypeName}_Filter`;
-    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${entity}_${FILTER_PROPS_SUFFIX}`]);
+    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${relatedEntity.filterInterfaceName}`]);
     const referencesTypeName = `${functionTypeName}_References`;
     const referencesTypeSource = generateInterfaceType(referencesTypeName, resolveReferences(endpoint.service, entities));
     const additionalPropertyTypeName = `${functionTypeName}_AdditionalProperty`;
     const additionalPropertyTypeSource = generateType(additionalPropertyTypeName, 'string');
     const queryTypeName = `${functionTypeName}_Query`;
-    const queryTypeSource = generateType(queryTypeName, `SomeQuery<${entity}, ${filterTypeName}, ${referencesTypeName}, ${additionalPropertyTypeName}> & ${parametersTypeName}`);
+    const queryTypeSource = generateType(queryTypeName, `SomeQuery<${relatedEntity.interfaceName}, ${filterTypeName}, ${referencesTypeName}, ${additionalPropertyTypeName}> & ${parametersTypeName}`);
     const referencedEntitiesTypeName = `${functionTypeName}_ReferencedEntities`;
     const referencedEntitiesTypeSource = generateInterfaceType(referencedEntitiesTypeName, resolveReferencedEntities(endpoint.service, entities));
     const additionalPropertiesTypeName = `${functionTypeName}_AdditionalProperties`;
-    const additionalPropertiesSchema = resolveAdditionalPropertiesSchema(path);
+    const additionalPropertiesSchema = resolveAdditionalPropertiesSchema(operationObject);
     const additionalPropertiesTypeSource = generateType(additionalPropertiesTypeName, additionalPropertiesSchema ? convertToTypeScriptType(additionalPropertiesSchema).toString() : '{}');
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: [`query${parametersType.isFullyOptional() ? '?' : ''}: ${queryTypeName}, requestOptions?: RequestOptions`],
-        returns: `${resolveResponseType(target)}<SomeQueryReturn<${entity}, ${referencedEntitiesTypeName}, ${additionalPropertiesTypeName}>>`
+        returns: `${resolveResponseType(options.target)}<SomeQueryReturn<${relatedEntity.interfaceName}, ${referencedEntitiesTypeName}, ${additionalPropertiesTypeName}>>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -876,7 +922,6 @@ const generateSomeEndpoint = ({ endpoint, target, path, entities, aliases }) =>
         params: ['query', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource },
@@ -892,14 +937,14 @@ const generateSomeEndpoint = ({ endpoint, target, path, entities, aliases }) =>
     };
 };
 
-const generateUniqueEndpoint = ({ target, path, endpoint }) => {
+const generateUniqueEndpoint = ({ operationObject, endpoint, context, options }) => {
     const functionName = 'unique';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: ['id: string', 'query?: Q', 'requestOptions?: RequestOptions'],
         generics: ['Q extends UniqueQuery'],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -908,25 +953,24 @@ const generateUniqueEndpoint = ({ target, path, endpoint }) => {
         returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, requestOptions)`
     });
     return {
-        entity: pascalCase(endpoint.service),
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource }
     };
 };
 
-const generateUpdateEndpoint = ({ target, path, endpoint }) => {
+const generateUpdateEndpoint = ({ endpoint, operationObject, context, options }) => {
     const functionName = 'update';
     const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
     const functionTypeSource = generateArrowFunctionType({
         type: functionTypeName,
         params: [
             'id: string',
-            `data: DeepPartial<${generateRequestBodyType(path).toString()}>`,
+            `data: DeepPartial<${generateRequestBodyType(operationObject, context.requestBodies).toString()}>`,
             'options?: UpdateQuery',
             'requestOptions?: RequestOptions'
         ],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
@@ -935,102 +979,77 @@ const generateUpdateEndpoint = ({ target, path, endpoint }) => {
         params: ['id', 'data', 'options', 'requestOptions?: RequestOptions']
     });
     return {
-        entity: pascalCase(endpoint.service),
         name: functionName,
         type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource }
     };
 };
 
-const isMultiPartUploadPath = (path) => {
-    const [, entity, ...rest] = path.split('/');
-    return entity && rest.length === 2 && rest[1] === 'multipartUpload';
-};
-const parseEndpointsAndGroupByEntity = (paths) => {
-    const endpoints = new Map();
-    for (const [rawPath, path] of Object.entries(paths)) {
-        const endpoint = parseEndpointPath(rawPath);
-        if (!endpoint || !path) {
-            // Todo: Should be removed if sdk supports multi part upload.
-            if (isMultiPartUploadPath(rawPath)) {
-                continue;
-            }
-            logger.errorLn(`Failed to parse ${rawPath}`);
-            continue;
-        }
-        if (endpoints.has(endpoint.service)) {
-            endpoints.get(endpoint.service)?.push({ endpoint, path });
-        }
-        else {
-            endpoints.set(endpoint.service, [{ endpoint, path }]);
-        }
-    }
-    return endpoints;
-};
-
 const generators = {
     /* /article */
     [WeclappEndpointType.ROOT]: {
-        get: generateSomeEndpoint,
-        post: generateCreateEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateSomeEndpoint,
+        [OpenAPIV3.HttpMethods.POST]: generateCreateEndpoint
     },
     /* /article/count */
     [WeclappEndpointType.COUNT]: {
-        get: generateCountEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateCountEndpoint
     },
     /* /article/:id */
     [WeclappEndpointType.ENTITY]: {
-        get: generateUniqueEndpoint,
-        delete: generateRemoveEndpoint,
-        put: generateUpdateEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateUniqueEndpoint,
+        [OpenAPIV3.HttpMethods.PUT]: generateUpdateEndpoint,
+        [OpenAPIV3.HttpMethods.DELETE]: generateRemoveEndpoint
     },
     /* /article/:id/method */
     [WeclappEndpointType.GENERIC_ENTITY]: {
-        get: generateGenericEndpoint('ById'),
-        post: generateGenericEndpoint('ById')
+        [OpenAPIV3.HttpMethods.GET]: generateGenericEndpoint('ById'),
+        [OpenAPIV3.HttpMethods.POST]: generateGenericEndpoint('ById')
     },
     /* /article/method */
     [WeclappEndpointType.GENERIC_ROOT]: {
-        get: generateGenericEndpoint(),
-        post: generateGenericEndpoint()
+        [OpenAPIV3.HttpMethods.GET]: generateGenericEndpoint(),
+        [OpenAPIV3.HttpMethods.POST]: generateGenericEndpoint()
     }
 };
-const generateServices = (paths, entities, aliases, options) => {
+const generateServices = (entities, context, options) => {
     const services = new Map();
-    const endpoints = parseEndpointsAndGroupByEntity(paths);
-    for (const [serviceName, paths] of endpoints) {
+    for (const [serviceName, serviceEndpoints] of context.endpoints) {
         const serviceFnName = camelCase(`${serviceName}Service`);
         const serviceTypeName = pascalCase(`${serviceName}Service`);
         const functions = [];
-        for (const { path, endpoint } of paths) {
-            const generator = generators[endpoint.type];
-            for (const [method, config] of Object.entries(path)) {
-                if ((method === 'get' && endpoint.type === WeclappEndpointType.ENTITY && !options.generateUnique) ||
-                    (method === 'post' && (endpoint.type === WeclappEndpointType.COUNT || endpoint.path.endsWith('query')))) {
+        for (const { path, endpoint } of serviceEndpoints) {
+            for (const method of [
+                OpenAPIV3.HttpMethods.GET,
+                OpenAPIV3.HttpMethods.POST,
+                OpenAPIV3.HttpMethods.PUT,
+                OpenAPIV3.HttpMethods.DELETE
+            ]) {
+                if ((method === OpenAPIV3.HttpMethods.GET &&
+                    endpoint.type === WeclappEndpointType.ENTITY &&
+                    !options.generateUnique) ||
+                    (method === OpenAPIV3.HttpMethods.POST &&
+                        (endpoint.type === WeclappEndpointType.COUNT || endpoint.path.endsWith('query')))) {
                     // Skip unique endpoints if generateUnique option is not set or if POST is used for filter queries
                     continue;
                 }
-                const generatorFn = generator[method];
-                if (generatorFn) {
-                    const path = config;
-                    const target = options.target;
-                    if (!path.deprecated || options.deprecated) {
+                const operationObject = path[method];
+                const generatorFn = generators[endpoint.type][method];
+                if (operationObject && generatorFn) {
+                    if (!operationObject.deprecated || options.deprecated) {
                         functions.push({
                             ...generatorFn({
-                                endpoint,
                                 method,
-                                target,
-                                path,
+                                endpoint,
+                                operationObject,
                                 entities,
-                                aliases
+                                context,
+                                options
                             }),
-                            path
+                            path: operationObject
                         });
                     }
                 }
-                else {
-                    logger.errorLn(`Failed to generate a function for ${method.toUpperCase()}:${endpoint.type} ${endpoint.path}`);
-                }
             }
         }
         if (!functions.length) {
@@ -1045,40 +1064,27 @@ const generateServices = (paths, entities, aliases, options) => {
             }))
         ])));
         const serviceFn = `export const ${serviceFnName} = (cfg?: ServiceConfig): ${serviceTypeName} => ${generateBlockStatements(...functions.map((v) => v.func.source), `return {${concat(functions.map((v) => v.func.name))}};`)};`;
+        const relatedEntityName = context.aliases.get(serviceName);
+        const relatedEntity = relatedEntityName ? entities.get(relatedEntityName) : undefined;
         services.set(serviceName, {
             name: serviceName,
             serviceFnName,
-            serviceTypeName,
             functions,
             source: generateStatements(serviceTypes, serviceFn),
-            deprecated: functions.every((v) => v.path.deprecated)
+            deprecated: functions.every((v) => v.path.deprecated),
+            relatedEntity
         });
     }
     return services;
 };
 
-const generateCustomValueServices = (entities, services) => {
-    const customValueEntity = entities.get('customValue');
+const generateCustomValueServices = (services) => {
     const customValueEntities = [];
-    if (!customValueEntity) {
-        logger.warn('Cannot generate custom value utils, type not found.');
-        return '';
-    }
-    serviceLoop: for (const service of services) {
-        const someFunction = service.functions.find((v) => v.name === 'some');
-        if (!someFunction) {
-            continue;
-        }
-        const entity = entities.get(camelCase(someFunction.entity));
-        if (entity?.properties.size !== customValueEntity.properties.size) {
-            continue;
-        }
-        for (const [prop, { type }] of entity.properties) {
-            if (customValueEntity.properties.get(prop)?.type !== type) {
-                continue serviceLoop;
-            }
+    for (const service of services) {
+        const relatedEntity = service.relatedEntity;
+        if (relatedEntity?.name === 'customValue') {
+            customValueEntities.push(service.name);
         }
-        customValueEntities.push(service.name);
     }
     return generateStatements(generateType('WCustomValueService', concat(generateStrings(customValueEntities), ' | ')), `export const wCustomValueServiceNames: WCustomValueService[] = [${concat(generateStrings(customValueEntities))}];`, `export const isWCustomValueService = (service: string | undefined): service is WCustomValueService =>\n${indent('wCustomValueServiceNames.includes(service as WCustomValueService);')}`);
 };
@@ -1123,14 +1129,19 @@ const generatePropertyDescriptors = (entity, entities, services, options) => [..
         value: value !== undefined ? (typeof value === 'number' ? value : generateString(value)) : undefined
     }))
 }));
-const generateEntityProperties = (entities, aliases, services, options) => {
+const generateEntityProperties = (entities, services, options) => {
     const typeName = 'WEntityProperties';
     const propertyMap = [
         ...entities.entries(),
-        ...[...aliases.entries()].map(([service, type]) => [service, entities.get(camelCase(type))])
-    ].map(([entity, data]) => ({
-        key: entity,
-        value: generatePropertyDescriptors(data, entities, services, options)
+        ...services
+            .filter(({ relatedEntity }) => !!relatedEntity)
+            .filter(({ name }) => !entities.get(name))
+            .map(({ name, relatedEntity }) => {
+            return [name, relatedEntity];
+        })
+    ].map(([entityName, entity]) => ({
+        key: entityName,
+        value: generatePropertyDescriptors(entity, entities, services, options)
     }));
     return generateStatements(`export type ${typeName} = Partial<Record<WEntity, Partial<Record<string, WEntityPropertyMeta>>>>;`, `export const wEntityProperties: ${typeName} = ${generateObject(propertyMap)};`);
 };
@@ -1180,7 +1191,7 @@ const generateGroupedServices = (services) => {
     }), ...typeGuards);
 };
 
-const generateMaps = (enums, entities, services, aliases, options) => {
+const generateMaps = (enums, entities, services, context, options) => {
     const enumInstances = `export const wEnums = ${generateObject([...enums.keys()].map((v) => ({ key: v, value: v })))};`;
     const entityNames = `export const wEntityNames: WEntity[] = ${generateArray([...entities.keys()])};`;
     const generatedServices = [...services.values()];
@@ -1194,75 +1205,116 @@ const generateMaps = (enums, entities, services, aliases, options) => {
         value: v.serviceFnName,
         comment: v.deprecated ? '@deprecated' : undefined
     })))};`;
-    return {
-        source: generateStatements(
-        /* Enums */
-        generateInterface('WEnums', [...enums.keys()].map((name) => ({ name, type: name, required: true }))), generateType('WEnum', 'keyof WEnums'), enumInstances, 
-        /* Entities */
-        generateInterface('WEntities', [
-            ...[...entities.keys()].map((name) => ({ name, type: loosePascalCase(name), required: true })),
-            ...[...aliases.entries()].map(([name, type]) => ({ name, type, required: true }))
-        ].sort((a, b) => (a.name > b.name ? 1 : -1))), generateType('WEntity', 'keyof WEntities'), entityNames, 
-        /* Services */
-        serviceInstances, generateType('WServices', 'typeof wServices'), generateType('WService', 'keyof WServices'), serviceFactories, generateType('WServiceFactories', 'typeof wServiceFactories'), 
-        /* Service Utils */
-        generateGroupedServices(generatedServices), generateCustomValueServices(entities, generatedServices), 
-        /* Entity Properties (Runtime Meta Infos) */
-        generateEntityProperties(entities, aliases, generatedServices, options))
-    };
+    return generateStatements(
+    /* Enums */
+    generateInterface('WEnums', [...enums.keys()].map((name) => ({ name, type: name, required: true }))), generateType('WEnum', 'keyof WEnums'), enumInstances, 
+    /* Entities */
+    generateInterface('WEntities', [
+        ...[...entities.entries()].map(([name, entity]) => ({
+            name,
+            type: entity.interfaceName,
+            required: true
+        })),
+        ...generatedServices
+            .filter(({ relatedEntity }) => !!relatedEntity)
+            .filter(({ name }) => !entities.get(name))
+            .map(({ name, relatedEntity }) => ({
+            name,
+            type: relatedEntity.interfaceName,
+            required: true
+        }))
+    ].sort((a, b) => (a.name > b.name ? 1 : -1))), generateType('WEntity', 'keyof WEntities'), entityNames, 
+    /* Services */
+    serviceInstances, generateType('WServices', 'typeof wServices'), generateType('WService', 'keyof WServices'), serviceFactories, generateType('WServiceFactories', 'typeof wServiceFactories'), 
+    /* Service Utils */
+    generateGroupedServices(generatedServices), generateCustomValueServices(generatedServices), 
+    /* Entity Properties (Runtime Meta Infos) */
+    generateEntityProperties(entities, generatedServices, options));
 };
 
-const parseReferencedEntityType = (obj) => pascalCase(obj.$ref.replace(/.*\//, ''));
-const extractServiceAliases = (doc, schemas) => {
-    const aliases = new Map();
-    for (const [path, methods] of Object.entries(doc.paths)) {
-        const parsed = parseEndpointPath(path);
-        if (!parsed || !methods || parsed.type !== WeclappEndpointType.ROOT || schemas.has(parsed.service)) {
-            continue;
+function extractRelatedEntityName(serviceEndpoints, responses) {
+    const rootEndpoint = serviceEndpoints.find((v) => v.endpoint.type === WeclappEndpointType.ROOT);
+    if (!rootEndpoint)
+        return;
+    const response = rootEndpoint?.path.get?.responses['200'];
+    if (!response)
+        return;
+    let responseObject;
+    if (isReferenceObject(response)) {
+        const refName = getRefName(response);
+        responseObject = responses.get(refName);
+    }
+    else {
+        responseObject = response;
+    }
+    const responseSchema = responseObject?.content?.['application/json'].schema;
+    if (responseSchema) {
+        if (isReferenceObject(responseSchema)) {
+            return;
         }
-        const body = methods[OpenAPIV3.HttpMethods.GET]?.responses['200'];
-        if (isResponseObject(body) && body.content?.['application/json']) {
-            const responseSchema = body.content['application/json'].schema;
-            if (!responseSchema || isReferenceObject(responseSchema)) {
-                continue;
-            }
-            const resultSchema = responseSchema.properties?.result;
-            if (!resultSchema) {
-                continue;
-            }
-            if (isReferenceObject(resultSchema)) {
-                aliases.set(parsed.service, parseReferencedEntityType(resultSchema));
-                continue;
-            }
-            if (isArraySchemaObject(resultSchema)) {
-                const resultItemSchema = resultSchema.items;
-                if (isReferenceObject(resultItemSchema)) {
-                    aliases.set(parsed.service, parseReferencedEntityType(resultItemSchema));
-                }
+        const resultSchema = responseSchema.properties?.result;
+        if (!resultSchema) {
+            return;
+        }
+        if (isReferenceObject(resultSchema)) {
+            return getRefName(resultSchema);
+        }
+        else if (isArraySchemaObject(resultSchema)) {
+            const resultItemSchema = resultSchema.items;
+            if (isReferenceObject(resultItemSchema)) {
+                return getRefName(resultItemSchema);
             }
         }
     }
+}
+
+const extractServiceAliases = (endpoints, responses) => {
+    const aliases = new Map();
+    for (const [serviceName, serviceEndpoints] of endpoints) {
+        const relatedEntityName = extractRelatedEntityName(serviceEndpoints, responses);
+        if (relatedEntityName)
+            aliases.set(serviceName, relatedEntityName);
+    }
     return aliases;
 };
-const extractSchemas = (doc) => {
+const extractContext = (doc) => {
+    const endpoints = parseEndpointsPaths(doc.paths);
     const schemas = new Map();
     for (const [name, schema] of Object.entries(doc.components?.schemas ?? {})) {
         if (!isReferenceObject(schema)) {
             schemas.set(name, schema);
         }
     }
-    const aliases = extractServiceAliases(doc, schemas);
-    return { schemas, aliases };
+    const responses = new Map();
+    for (const [name, response] of Object.entries(doc.components?.responses ?? {})) {
+        if (!isReferenceObject(response)) {
+            responses.set(name, response);
+        }
+    }
+    const parameters = new Map();
+    for (const [name, parameter] of Object.entries(doc.components?.parameters ?? {})) {
+        if (!isReferenceObject(parameter)) {
+            parameters.set(name, parameter);
+        }
+    }
+    const requestBodies = new Map();
+    for (const [name, requestBody] of Object.entries(doc.components?.requestBodies ?? {})) {
+        if (!isReferenceObject(requestBody)) {
+            requestBodies.set(name, requestBody);
+        }
+    }
+    const aliases = extractServiceAliases(endpoints, responses);
+    return { endpoints, schemas, responses, parameters, requestBodies, aliases };
 };
 
 const generate = (doc, options) => {
-    const { schemas, aliases } = extractSchemas(doc);
-    const enums = generateEnums(schemas);
-    const entities = generateEntities(schemas, enums);
-    const entityFilterProps = generateEntityFilterProps(entities, enums);
-    const services = generateServices(doc.paths, entities, aliases, options);
-    const maps = generateMaps(enums, entities, services, aliases, options);
-    return generateStatements(generateBase(options.target, doc.info.version, options), generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map((v) => v.source))), generateBlockComment('ENTITY FILTER PROPS', generateStatements(...[...entityFilterProps.values()].map((v) => v.source))), generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map((v) => v.source))), generateBlockComment('SERVICES', generateStatements(...[...services.values()].map((v) => v.source))), generateBlockComment('MAPS', generateStatements(maps.source)));
+    const context = extractContext(doc);
+    const base = generateBase(doc.info.version, options);
+    const enums = generateEnums(context);
+    const entities = generateEntities(context);
+    const services = generateServices(entities, context, options);
+    const maps = generateMaps(enums, entities, services, context, options);
+    return generateStatements(generateBlockComment('BASE', base), generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map((v) => v.source))), generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map((v) => v.source))), generateBlockComment('FILTERS', generateStatements(...[...entities.values()].map((v) => v.filterSource))), generateBlockComment('SERVICES', generateStatements(...[...services.values()].map((v) => v.source))), generateBlockComment('MAPS', maps));
 };
 
 const hash = (content, algorithm = 'sha256') => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weclapp/sdk",
-  "version": "2.0.0-dev.50",
+  "version": "2.0.0-dev.51",
   "description": "weclapp SDK Generator",
   "author": "weclapp",
   "sideEffects": false,
@@ -39,10 +39,14 @@
   "scripts": {
     "build": "rollup --config rollup.config.ts --configPlugin typescript={tsconfig:\\'tsconfig.node.json\\'} --configImportAttributesKey with",
     "build:watch": "npm run build -- --watch",
-    "cli:browser": "./bin/cli.js test/openapi.json --target browser",
-    "cli:browser:cache": "./bin/cli.js test/openapi.json --target browser --cache",
-    "cli:browser.rx": "./bin/cli.js test/openapi.json --target browser.rx",
-    "cli:browser.rx:cache": "./bin/cli.js test/openapi.json --target browser.rx --cache",
+    "cli:browser:v1": "./bin/cli.js test/openapi.json --target browser",
+    "cli:browser.rx:v1": "./bin/cli.js test/openapi.json --target browser.rx",
+    "cli:browser:v2": "./bin/cli.js test/openapi_v2.json --target browser",
+    "cli:browser.rx:v2": "./bin/cli.js test/openapi_v2.json --target browser.rx",
+    "cli:browser:v3": "./bin/cli.js test/openapi_v3.json --target browser",
+    "cli:browser:v3:cache": "./bin/cli.js test/openapi_v3.json --target browser --cache",
+    "cli:browser.rx:v3": "./bin/cli.js test/openapi_v3.json --target browser.rx",
+    "cli:browser.rx:v3:cache": "./bin/cli.js test/openapi_v3.json --target browser.rx --cache",
     "cli:node": "./bin/cli.js test/openapi.json --target node",
     "cli:node:cache": "./bin/cli.js test/openapi.json --target node  --cache",
     "cli:node.rx": "./bin/cli.js test/openapi.json --target node.rx",
@@ -51,7 +55,7 @@
     "prettier:fix": "prettier . --write",
     "lint": "eslint ./src --cache",
     "lint:fix": "npm run lint -- --fix",
-    "ci": "npm run prettier && npm run lint && npm run build && npm run cli:browser",
+    "ci": "npm run prettier && npm run lint && npm run build && npm run cli:browser:v1 && npm run cli:browser:v2 && npm run cli:browser:v3",
     "release": "standard-version"
   },
   "devDependencies": {