@opra/cli 1.0.0-alpha.9 → 1.0.0-beta.1

package/esm/ts-generator/generators/generate-data-type.js

@@ -0,0 +1,248 @@
+import path from 'node:path';
+import { ComplexType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
+import { CodeBlock } from '../../code-block.js';
+import { wrapJSDocString } from '../utils/string-utils.js';
+const internalTypeNames = ['any', 'boolean', 'bigint', 'number', 'null', 'string', 'object'];
+export async function generateDataType(dataType, intent, currentFile) {
+    const doc = dataType.node.getDocument();
+    if (doc.id !== this._document?.id) {
+        const { generator } = await this.generateDocument(doc);
+        return await generator.generateDataType(dataType, intent, currentFile);
+    }
+    const typeName = dataType.name;
+    if (typeName) {
+        if (internalTypeNames.includes(typeName))
+            return { kind: 'internal', typeName: dataType.name };
+        let file = this._filesMap.get(dataType);
+        if (file) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        if (dataType instanceof SimpleType)
+            file = this.addFile(path.join(this._documentRoot, '/simple-types.ts'), true);
+        else if (dataType instanceof EnumType) {
+            file = this.addFile(path.join(this._typesRoot, 'enums', typeName + '.ts'), true);
+        }
+        else
+            file = this.addFile(path.join(this._typesRoot, 'types', typeName + '.ts'), true);
+        this._filesMap.set(dataType, file);
+        if (file.exportTypes.includes(typeName)) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        file.exportTypes.push(typeName);
+        const typesIndexTs = this.addFile(path.join(this._typesRoot, 'index.ts'), true);
+        const indexTs = this.addFile('/index.ts', true);
+        indexTs.addExport(typesIndexTs.filename, undefined, this._typesNamespace);
+        const codeBlock = (file.code['type_' + typeName] = new CodeBlock());
+        codeBlock.head = `/**\n * ${wrapJSDocString(dataType.description || '')}\n *`;
+        codeBlock.head += `
+ * @url ${path.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
+ */
+export `;
+        codeBlock.typeDef = (await this._generateTypeCode(file, dataType, 'root')) + '\n\n';
+        typesIndexTs.addExport(file.filename);
+        if (currentFile)
+            currentFile.addImport(file.filename, [typeName]);
+        return { kind: 'named', file, typeName };
+    }
+    if (!currentFile)
+        throw new TypeError(`You must provide currentFile to generate data type`);
+    const code = await this._generateTypeCode(currentFile, dataType, intent);
+    return { kind: 'embedded', code };
+}
+/**
+ *
+ */
+export async function _generateTypeCode(currentFile, dataType, intent) {
+    if (intent === 'root' && !dataType.name) {
+        throw new TypeError(`Name required to generate data type code to root intent`);
+    }
+    if (dataType instanceof EnumType) {
+        return await this._generateEnumTypeCode(currentFile, dataType, intent);
+    }
+    if (dataType instanceof ComplexType) {
+        return await this._generateComplexTypeCode(currentFile, dataType, intent);
+    }
+    if (dataType instanceof SimpleType) {
+        return await this._generateSimpleTypeCode(currentFile, dataType, intent);
+    }
+    if (dataType instanceof MappedType) {
+        return await this._generateMappedTypeCode(currentFile, dataType, intent);
+    }
+    if (dataType instanceof MixinType) {
+        return await this._generateMixinTypeCode(currentFile, dataType, intent);
+    }
+    /* istanbul ignore next */
+    throw new TypeError(`${dataType.kind} data types can not be directly exported`);
+}
+/**
+ *
+ */
+export async function _generateEnumTypeCode(currentFile, dataType, intent) {
+    if (intent === 'root') {
+        let out = `enum ${dataType.name} {\n\t`;
+        for (const [value, info] of Object.entries(dataType.attributes)) {
+            // Print JSDoc
+            let jsDoc = '';
+            if (dataType.attributes[value].description)
+                jsDoc += ` * ${dataType.attributes[value].description}\n`;
+            if (jsDoc)
+                out += `/**\n${jsDoc} */\n`;
+            out +=
+                `${info.alias || value} = ` +
+                    (typeof value === 'number' ? value : "'" + String(value).replace("'", "\\'") + "'");
+            out += ',\n\n';
+        }
+        return out + '\b}';
+    }
+    return ('(' +
+        Object.keys(dataType.attributes)
+            .map(t => `'${t}'`)
+            .join(' | ') +
+        ')');
+}
+/**
+ *
+ */
+export async function _generateComplexTypeCode(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `interface ${dataType.name} ` : '';
+    const ownFields = [...dataType.fields.values()].filter(f => f.origin === dataType);
+    if (dataType.base) {
+        const base = await this.generateDataType(dataType.base, 'extends', currentFile);
+        let baseDef = base.kind === 'embedded' ? base.code : base.typeName;
+        const omitBaseFields = ownFields.filter(f => dataType.base.fields.has(f.name));
+        if (omitBaseFields.length)
+            baseDef = `Omit<${baseDef}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`;
+        if (intent === 'root')
+            out += `extends ${baseDef} `;
+        else {
+            out += baseDef;
+            if (!ownFields.length)
+                return out;
+            out += ' & ';
+        }
+    }
+    out += '{\n\t';
+    let i = 0;
+    for (const field of ownFields) {
+        if (i++)
+            out += '\n';
+        // Print JSDoc
+        out += `/**\n * ${field.description || ''}\n`;
+        if (field.default)
+            out += ` * @default ` + field.default + '\n';
+        // if (field.format)
+        //   jsDoc += ` * @format ` + field.format + '\n';
+        if (field.exclusive)
+            out += ` * @exclusive\n`;
+        if (field.readonly)
+            out += ` * @readonly\n`;
+        if (field.writeonly)
+            out += ` * @writeonly\n`;
+        if (field.deprecated) {
+            out += ` * @deprecated ` + (typeof field.deprecated === 'string' ? field.deprecated : '') + '\n';
+        }
+        out += ' */\n';
+        // Print field name
+        if (field.readonly)
+            out += 'readonly ';
+        out += `${field.name}${field.required ? '' : '?'}: `;
+        if (field.fixed) {
+            const t = typeof field.fixed;
+            out += `${t === 'number' || t === 'boolean' || t === 'bigint' ? field.fixed : "'" + field.fixed + "'"}\n`;
+        }
+        else {
+            const x = await this.generateDataType(field.type, 'typeDef', currentFile);
+            out += (x.kind === 'embedded' ? x.code : x.typeName) + `${field.isArray ? '[]' : ''};\n`;
+        }
+    }
+    if (dataType.additionalFields)
+        out += '[key: string]: any;\n';
+    return out + '\b}';
+}
+/**
+ *
+ */
+export async function _generateSimpleTypeCode(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
+    out += dataType.nameMappings.js || 'any';
+    return intent === 'root' ? out + ';' : out;
+}
+/**
+ *
+ */
+export async function _generateMixinTypeCode(currentFile, dataType, intent) {
+    const outArray = [];
+    for (const t of dataType.types) {
+        const x = await this.generateDataType(t, 'typeDef', currentFile);
+        if (x.kind === 'embedded') {
+            outArray.push(x.code.includes('|') ? '(' + x.code + ')' : x.code);
+        }
+        else
+            outArray.push(x.typeName);
+    }
+    if (intent === 'root')
+        return `type ${dataType.name} = ${outArray.join(' & ')}`;
+    if (intent === 'extends')
+        return outArray.join(', ');
+    return outArray.join(' & ');
+}
+/**
+ *
+ */
+export async function _generateMappedTypeCode(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
+    const base = await this.generateDataType(dataType.base, 'typeDef', currentFile);
+    const typeDef = base.kind === 'embedded' ? base.code : base.typeName;
+    const pick = dataType.pick?.length ? dataType.pick : undefined;
+    const omit = !pick && dataType.omit?.length ? dataType.omit : undefined;
+    const partial = dataType.partial === true || (Array.isArray(dataType.partial) && dataType.partial.length > 0)
+        ? dataType.partial
+        : undefined;
+    const required = dataType.required === true || (Array.isArray(dataType.required) && dataType.required.length > 0)
+        ? dataType.required
+        : undefined;
+    if (!(pick || omit || partial || required))
+        return typeDef;
+    if (partial === true)
+        out += 'Partial<';
+    else if (partial) {
+        out += 'PartialSome<';
+        currentFile.addExport('ts-gems', ['PartialSome']);
+    }
+    if (required === true)
+        out += 'Partial<';
+    else if (required) {
+        out += 'RequiredSome<';
+        currentFile.addExport('ts-gems', ['RequiredSome']);
+    }
+    if (pick)
+        out += 'Pick<';
+    else if (omit)
+        out += 'Omit<';
+    out += typeDef;
+    if (omit || pick) {
+        out +=
+            ', ' +
+                (omit || pick)
+                    .filter(x => !!x)
+                    .map(x => `'${x}'`)
+                    .join(' | ') +
+                '>';
+    }
+    if (partial) {
+        if (Array.isArray(partial)) {
+            out +=
+                ', ' +
+                    partial
+                        .filter(x => !!x)
+                        .map(x => `'${x}'`)
+                        .join(' | ');
+        }
+        out += '>';
+    }
+    return out;
+}

package/esm/ts-generator/{processors/process-document.js → generators/generate-document.js}

@@ -1,16 +1,16 @@
+import path from 'node:path';
 import { OpraHttpClient } from '@opra/client';
-import { HttpApi } from '@opra/common';
-import chalk from 'chalk';
-import path from 'path';
+import { BUILTIN, HttpApi } from '@opra/common';
+import colors from 'ansi-colors';
 import { pascalCase } from 'putil-varhelpers';
-export async function processDocument(document, options) {
+export async function generateDocument(document, options) {
     if (!document || typeof document === 'string') {
         if (document) {
             const out = this._documentsMap.get(document);
             if (out)
                 return out;
         }
-        this.emit('log', chalk.cyan('Fetching document schema from ') + chalk.blueBright(this.serviceUrl));
+        this.emit('log', colors.cyan('Fetching document schema from ') + colors.blueBright(this.serviceUrl));
         const client = new OpraHttpClient(this.serviceUrl);
         document = await client.fetchDocument({ documentId: document });
     }
@@ -23,15 +23,20 @@ export async function processDocument(document, options) {
         generator: this,
     };
     this._documentsMap.set(document.id, out);
-    this.emit('log', chalk.white('[' + document.id + '] ') + chalk.cyan('Processing document ') + chalk.magenta(document.info.title));
+    this.emit('log', colors.white('[' + document.id + '] ') +
+        colors.cyan('Processing document ') +
+        colors.magenta(document.info.title || ''));
     if (document.references.size) {
-        this.emit('log', chalk.white('[' + document.id + '] ') + chalk.cyan(`Processing references`));
+        let refIdGenerator = options?.refIdGenerator || 1;
+        this.emit('log', colors.white('[' + document.id + '] ') + colors.cyan(`Processing references`));
         for (const ref of document.references.values()) {
             const generator = this.extend();
             generator._document = ref;
-            generator._documentRoot = '/references/' + (ref.info.title ? pascalCase(ref.info.title) : ref.id);
+            const typesNamespace = ref.api?.name || (ref.info.title ? pascalCase(ref.info.title) : `Reference${refIdGenerator++}`);
+            generator._documentRoot = '/references/' + typesNamespace;
             generator._typesRoot = path.join(generator._documentRoot, 'models');
-            await generator.processDocument(ref, { typesOnly: true });
+            generator._typesNamespace = !this.options.referenceNamespaces || ref[BUILTIN] ? '' : typesNamespace;
+            await generator.generateDocument(ref, { typesOnly: true, refIdGenerator });
         }
     }
     this._fileHeaderDocInfo = `/*
@@ -41,15 +46,15 @@ export async function processDocument(document, options) {
  * ${this.serviceUrl}
  */`;
     if (document.types.size) {
-        this.emit('log', chalk.white('[' + document.id + ']'), chalk.cyan(`Processing data types`));
+        this.emit('log', colors.white('[' + document.id + ']'), colors.cyan(`Processing data types`));
         for (const t of document.types.values()) {
-            await this.processDataType(t);
+            await this.generateDataType(t, 'root');
         }
     }
     if (options?.typesOnly)
         return out;
     if (document.api instanceof HttpApi) {
-        await this.processHttpApi(document.api);
+        await this.generateHttpApi(document.api);
     }
     return out;
 }

package/esm/ts-generator/{processors/process-http-api.js → generators/generate-http-api.js}

@@ -3,7 +3,7 @@ import { camelCase, pascalCase } from 'putil-varhelpers';
 import { CodeBlock } from '../../code-block.js';
 import { httpControllerNodeScript } from '../http-controller-node.js';
 import { wrapJSDocString } from '../utils/string-utils.js';
-export async function processHttpApi(api) {
+export async function generateHttpApi(api) {
     let file = this._filesMap.get(api);
     if (file)
         return file;
@@ -28,7 +28,7 @@ export async function processHttpApi(api) {
     classConstBlock.tail = `\b\n}\n`;
     for (const controller of api.controllers.values()) {
         const generator = this.extend();
-        const f = await generator.processHttpController(controller);
+        const f = await generator.generateHttpController(controller);
         const childClassName = pascalCase(controller.name) + 'Controller';
         file.addImport('.' + f.filename, [childClassName]);
         const property = '$' + controller.name.charAt(0).toLowerCase() + camelCase(controller.name.substring(1));

package/esm/ts-generator/generators/generate-http-controller.js

@@ -0,0 +1,292 @@
+import path from 'node:path';
+import typeIs from '@browsery/type-is';
+import { ComplexType, HttpController, MimeTypes } from '@opra/common';
+import { camelCase, pascalCase } from 'putil-varhelpers';
+import { CodeBlock } from '../../code-block.js';
+import { locateNamedType } from '../utils/locate-named-type.js';
+import { wrapJSDocString } from '../utils/string-utils.js';
+export async function generateHttpController(controller) {
+    let file = this._filesMap.get(controller);
+    if (file)
+        return file;
+    const generateParamDoc = async (name, type, options) => {
+        let typeDef;
+        if (type) {
+            const xt = await this.generateDataType(type, 'typeDef', file);
+            typeDef = xt.kind === 'embedded' ? 'object' : xt.typeName;
+        }
+        else
+            typeDef = 'any';
+        if (options?.isArray)
+            typeDef += '[]';
+        let out = `\n * @param {${typeDef}} ` + (options?.required ? name : `[${name}]`);
+        if (options?.description)
+            out += `  - ${wrapJSDocString(options?.description)}`;
+        if (type instanceof ComplexType && type.embedded) {
+            for (const f of type.fields.values()) {
+                out += await generateParamDoc(name + '.' + f.name, f.type, f);
+            }
+        }
+        return out;
+    };
+    const className = pascalCase(controller.name) + 'Controller';
+    file = this.addFile(path.join(this._apiPath, className + '.ts'));
+    file.addImport('@opra/client', ['HttpRequestObservable', 'kClient', 'OpraHttpClient']);
+    file.addImport(path.relative(file.dirname, '/http-controller-node.ts'), ['HttpControllerNode']);
+    const classBlock = (file.code[className] = new CodeBlock());
+    classBlock.doc = `/** 
+ * ${wrapJSDocString(controller.description || '')}
+ * @class ${className}
+ * @apiUrl ${path.posix.join(this.serviceUrl, controller.getFullUrl())}
+ */`;
+    classBlock.head = `\nexport class ${className} extends HttpControllerNode {\n\t`;
+    classBlock.properties = '';
+    const classConstBlock = (classBlock.classConstBlock = new CodeBlock());
+    classConstBlock.head = `\n/**
+ * @param {OpraHttpClient} client - OpraHttpClient instance to operate
+ * @constructor
+ */  
+constructor(client: OpraHttpClient) {`;
+    classConstBlock.body = `\n\tsuper(client);`;
+    classConstBlock.tail = `\b\n}\n`;
+    if (controller.controllers.size) {
+        for (const child of controller.controllers.values()) {
+            const generator = this.extend();
+            generator._apiPath = path.join(this._apiPath, className);
+            const f = await generator.generateHttpController(child);
+            const childClassName = pascalCase(child.name) + 'Controller';
+            file.addImport(f.filename, [childClassName]);
+            const property = '$' + child.name.charAt(0).toLowerCase() + camelCase(child.name.substring(1));
+            classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+            classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+        }
+    }
+    /** Process operations */
+    const mergedControllerParams = [...controller.parameters];
+    let _base = controller;
+    while (_base.owner instanceof HttpController) {
+        _base = _base.owner;
+        mergedControllerParams.unshift(..._base?.parameters);
+    }
+    for (const operation of controller.operations.values()) {
+        const mergedParams = [...mergedControllerParams, ...operation.parameters];
+        const operationBlock = (classBlock['operation_' + operation.name] = new CodeBlock());
+        operationBlock.doc = new CodeBlock();
+        operationBlock.doc.header = `
+/** 
+ * ${wrapJSDocString(operation.description || operation.name + ' operation')}`;
+        operationBlock.doc.parameters = new CodeBlock();
+        if (mergedParams.length) {
+            const block = new CodeBlock();
+            block.doc = '\n *\n * RegExp parameters:';
+            let i = 0;
+            for (const prm of operation.parameters) {
+                if (!(prm.name instanceof RegExp))
+                    continue;
+                i++;
+                block.doc +=
+                    `\n *   > ${String(prm.name)} - ${prm.description || ''}` +
+                        `\n *       - location: ${prm.location}` +
+                        `\n *       - type: ${locateNamedType(prm.type)?.name || 'any'}${prm.isArray ? '[' + prm.arraySeparator + ']' : ''}` +
+                        (prm.required ? `\n *      required: ${prm.required}` : '') +
+                        (prm.deprecated ? `\n *      deprecated: ${prm.deprecated}` : '');
+            }
+            if (i)
+                operationBlock.doc.regExParameters = block;
+        }
+        operationBlock.doc.tail = `
+ * @apiUrl ${path.posix.join(this.serviceUrl, operation.getFullUrl())}    
+ */\n`;
+        operationBlock.head = `${operation.name}(`;
+        /** Process operation parameters */
+        const pathParams = [];
+        const queryParams = [];
+        const headerParams = [];
+        if (mergedParams.length) {
+            const pathParamsMap = {};
+            const queryParamsMap = {};
+            const headerParamsMap = {};
+            for (const prm of mergedParams) {
+                if (typeof prm.name !== 'string')
+                    continue;
+                if (prm.location === 'path')
+                    pathParamsMap[prm.name] = prm;
+                if (prm.location === 'query')
+                    queryParamsMap[prm.name] = prm;
+                if (prm.location === 'header')
+                    headerParamsMap[prm.name] = prm;
+            }
+            pathParams.push(...Object.values(pathParamsMap));
+            queryParams.push(...Object.values(queryParamsMap));
+            headerParams.push(...Object.values(headerParamsMap));
+        }
+        /** Process path parameters and add as function arguments */
+        let argIndex = 0;
+        for (const prm of pathParams) {
+            let typeDef;
+            if (prm.type) {
+                const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            else
+                typeDef = `any`;
+            if (prm.isArray)
+                typeDef += '[]';
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += `${prm.name}: ${typeDef}`;
+            operationBlock.doc.parameters +=
+                `\n * @param {${typeDef}} ` +
+                    (prm.required ? prm.name : `[${prm.name}]`) +
+                    (prm.description ? ' - ' + wrapJSDocString(prm.description || '') : '');
+        }
+        /** Process requestBody and add as function argument ($body) */
+        let hasBody = false;
+        if (operation.requestBody?.content.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            let typeArr = [];
+            for (const content of operation.requestBody.content) {
+                if (content.type) {
+                    /** Generate JSDoc for parameter */
+                    operationBlock.doc.parameters += await generateParamDoc('$body', content.type, {
+                        required: operation.requestBody.required,
+                        description: content.description || content.type.description,
+                    });
+                    /**  */
+                    const xt = await this.generateDataType(content.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (typeDef === 'any') {
+                        typeArr = [];
+                        break;
+                    }
+                    if (xt.kind === 'named') {
+                        if (operation.requestBody.partial) {
+                            file.addImport('ts-gems', ['PartialDTO']);
+                            typeDef = `PartialDTO<${typeDef}>`;
+                        }
+                        else {
+                            file.addImport('ts-gems', ['DTO']);
+                            typeDef = `DTO<${typeDef}>`;
+                        }
+                    }
+                    if (typeDef && content.isArray)
+                        typeDef += '[]';
+                    typeDef = typeDef || 'undefined';
+                    if (!typeArr.includes(typeDef))
+                        typeArr.push(typeDef);
+                    continue;
+                }
+                else if (content.contentType && typeIs.is(String(content.contentType), ['multipart/*'])) {
+                    const typeDef = 'FormData';
+                    if (!typeArr.includes(typeDef))
+                        typeArr.push(typeDef);
+                    continue;
+                }
+                typeArr = [];
+                break;
+            }
+            const typeDef = typeArr.join(' | ') || 'any';
+            operationBlock.head += `$body: ${typeDef}`;
+            // operationBlock.doc.parameters += `\n * @param {${typeDef}} $body - Http body` + bodyFields;
+            hasBody = true;
+        }
+        /** process query params */
+        const isQueryRequired = queryParams.find(p => p.required);
+        const isHeadersRequired = queryParams.find(p => p.required);
+        if (queryParams.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += '\n\t$params' + (isHeadersRequired || isQueryRequired ? '' : '?') + ': {\n\t';
+            operationBlock.doc.parameters += '\n * @param {object} $params - Available parameters for the operation';
+            let hasAdditionalFields = false;
+            for (const prm of queryParams) {
+                if (typeof prm.name !== 'string') {
+                    hasAdditionalFields = true;
+                    continue;
+                }
+                operationBlock.doc.parameters += await generateParamDoc('$params.' + prm.name, prm.type, prm);
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (prm.type) {
+                    const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (prm.isArray)
+                        typeDef += '[]';
+                    operationBlock.head += `${typeDef};\n`;
+                }
+                else
+                    operationBlock.head += `any;\n`;
+            }
+            if (hasAdditionalFields) {
+                operationBlock.head += '[index: string]: any;\n';
+            }
+            operationBlock.head += '\b}\b';
+        }
+        /** process header params */
+        if (headerParams.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', \n';
+            operationBlock.head += '\t$headers' + (isHeadersRequired ? '' : '?') + ': {\n\t';
+            for (const prm of headerParams) {
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (prm.type) {
+                    const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (prm.isArray)
+                        typeDef += '[]';
+                    operationBlock.head += `${typeDef};\n`;
+                }
+                else
+                    operationBlock.head += `any;\n`;
+            }
+            operationBlock.head += '\b}\b';
+        }
+        /* Determine return type */
+        const returnTypes = [];
+        let typeDef = '';
+        for (const resp of operation.responses) {
+            if (!resp.statusCode.find(r => r.intersects(200, 299)))
+                continue;
+            typeDef = '';
+            if (resp.type) {
+                const xt = await this.generateDataType(resp.type, 'typeDef', file);
+                typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            if (typeDef) {
+                if (typeDef !== 'OperationResult') {
+                    if (resp.partial) {
+                        file.addImport('ts-gems', ['PartialDTO']);
+                        typeDef = `PartialDTO<${typeDef}>`;
+                    }
+                    else {
+                        file.addImport('ts-gems', ['DTO']);
+                        typeDef = `DTO<${typeDef}>`;
+                    }
+                }
+            }
+            if (typeDef && resp.isArray)
+                typeDef += '[]';
+            if (resp.contentType && typeIs.is(String(resp.contentType), [MimeTypes.opra_response_json])) {
+                file.addImport('@opra/common', ['OperationResult']);
+                typeDef = typeDef ? `OperationResult<${typeDef}>` : 'OperationResult';
+            }
+            typeDef = typeDef || 'undefined';
+            if (!returnTypes.includes(typeDef))
+                returnTypes.push(typeDef);
+        }
+        operationBlock.head += `\n): HttpRequestObservable<${returnTypes.join(' | ') || 'any'}>{`;
+        operationBlock.body = `\n\t`;
+        operationBlock.body +=
+            `const url = this._prepareUrl('${operation.getFullUrl()}', {` + pathParams.map(p => p.name).join(', ') + '});';
+        operationBlock.body +=
+            `\nreturn this[kClient].request(url, { method: '${operation.method}'` +
+                (hasBody ? ', body: $body' : '') +
+                (queryParams.length ? ', params: $params as any' : '') +
+                (headerParams.length ? ', headers: $headers as any' : '') +
+                '});';
+        operationBlock.tail = `\b\n};\n`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}