@opra/cli 1.0.0-alpha.12 → 1.0.0-alpha.14

package/cjs/ts-generator/ts-generator.js

@@ -8,11 +8,11 @@ const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const node_process_1 = tslib_1.__importDefault(require("node:process"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const file_writer_js_1 = require("../file-writer.js");
-const clean_directory_js_1 = require("./processors/clean-directory.js");
-const process_data_types_js_1 = require("./processors/process-data-types.js");
-const process_document_js_1 = require("./processors/process-document.js");
-const process_http_api_js_1 = require("./processors/process-http-api.js");
-const process_http_controller_js_1 = require("./processors/process-http-controller.js");
+const clean_directory_js_1 = require("./generators/clean-directory.js");
+const generate_data_type_js_1 = require("./generators/generate-data-type.js");
+const generate_document_js_1 = require("./generators/generate-document.js");
+const generate_http_api_js_1 = require("./generators/generate-http-api.js");
+const generate_http_controller_js_1 = require("./generators/generate-http-controller.js");
 const ts_file_js_1 = require("./ts-file.js");
 /**
  * @class TsGenerator
@@ -49,7 +49,7 @@ class TsGenerator extends node_events_1.EventEmitter {
             this.emit('log', chalk_1.default.cyan('Removing old files..'));
             this.cleanDirectory(this.outDir);
             this._apiPath = '/api';
-            await this.processDocument();
+            await this.generateDocument();
             const { importExt } = this.options;
             // Write files
             for (const file of Object.values(this._files)) {
@@ -95,15 +95,14 @@ class TsGenerator extends node_events_1.EventEmitter {
 exports.TsGenerator = TsGenerator;
 (() => {
     TsGenerator.prototype.cleanDirectory = clean_directory_js_1.cleanDirectory;
-    TsGenerator.prototype.processDocument = process_document_js_1.processDocument;
-    TsGenerator.prototype.processDataType = process_data_types_js_1.processDataType;
-    TsGenerator.prototype.processHttpApi = process_http_api_js_1.processHttpApi;
-    TsGenerator.prototype.processHttpController = process_http_controller_js_1.processHttpController;
-    TsGenerator.prototype.generateTypeDefinition = process_data_types_js_1.generateTypeDefinition;
-    TsGenerator.prototype.generateEnumTypeDefinition = process_data_types_js_1.generateEnumTypeDefinition;
-    TsGenerator.prototype.generateComplexTypeDefinition = process_data_types_js_1.generateComplexTypeDefinition;
-    TsGenerator.prototype.generateSimpleTypeDefinition = process_data_types_js_1.generateSimpleTypeDefinition;
-    TsGenerator.prototype.generateMappedTypeDefinition = process_data_types_js_1.generateMappedTypeDefinition;
-    TsGenerator.prototype.generateMixinTypeDefinition = process_data_types_js_1.generateMixinTypeDefinition;
-    // TsGenerator.prototype.resolveTypeNameOrDef = resolveTypeNameOrDef;
+    TsGenerator.prototype.generateDocument = generate_document_js_1.generateDocument;
+    TsGenerator.prototype.generateDataType = generate_data_type_js_1.generateDataType;
+    TsGenerator.prototype._generateTypeCode = generate_data_type_js_1._generateTypeCode;
+    TsGenerator.prototype._generateEnumTypeCode = generate_data_type_js_1._generateEnumTypeCode;
+    TsGenerator.prototype._generateComplexTypeCode = generate_data_type_js_1._generateComplexTypeCode;
+    TsGenerator.prototype._generateSimpleTypeCode = generate_data_type_js_1._generateSimpleTypeCode;
+    TsGenerator.prototype._generateMappedTypeCode = generate_data_type_js_1._generateMappedTypeCode;
+    TsGenerator.prototype._generateMixinTypeCode = generate_data_type_js_1._generateMixinTypeCode;
+    TsGenerator.prototype.generateHttpApi = generate_http_api_js_1.generateHttpApi;
+    TsGenerator.prototype.generateHttpController = generate_http_controller_js_1.generateHttpController;
 })();

package/esm/ts-generator/generators/clean-directory.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+export function cleanDirectory(dirname) {
+    const rootDir = dirname;
+    const _cleanDirectory = (targetDir) => {
+        if (!fs.existsSync(targetDir))
+            return;
+        const files = fs.readdirSync(targetDir);
+        for (const f of files) {
+            const absolutePath = path.join(targetDir, f);
+            if (fs.statSync(absolutePath).isDirectory()) {
+                _cleanDirectory(absolutePath);
+                if (!fs.readdirSync(absolutePath).length) {
+                    this.emit('verbose', chalk.cyan(`Removing directory ${path.relative(absolutePath, rootDir)}`));
+                    fs.rmdirSync(absolutePath);
+                }
+                continue;
+            }
+            if (path.extname(f) === '.ts') {
+                const contents = fs.readFileSync(absolutePath, 'utf-8');
+                if (contents.includes('#!oprimp_auto_generated!#')) {
+                    this.emit('verbose', chalk.cyan(`Removing file ${path.relative(absolutePath, rootDir)}`));
+                    fs.unlinkSync(absolutePath);
+                }
+            }
+        }
+    };
+    _cleanDirectory(dirname);
+}

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

@@ -0,0 +1,247 @@
+import { ComplexType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
+import path from 'path';
+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'));
+        else
+            file = this.addFile(path.join(this._typesRoot, 'types', typeName + '.ts'));
+        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);
+        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/generators/generate-document.js

@@ -0,0 +1,55 @@
+import { OpraHttpClient } from '@opra/client';
+import { HttpApi } from '@opra/common';
+import chalk from 'chalk';
+import path from 'path';
+import { pascalCase } from 'putil-varhelpers';
+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));
+        const client = new OpraHttpClient(this.serviceUrl);
+        document = await client.fetchDocument({ documentId: document });
+    }
+    this._document = document;
+    let out = this._documentsMap.get(document.id);
+    if (out)
+        return out;
+    out = {
+        document,
+        generator: this,
+    };
+    this._documentsMap.set(document.id, out);
+    this.emit('log', chalk.white('[' + document.id + '] ') + chalk.cyan('Processing document ') + chalk.magenta(document.info.title));
+    if (document.references.size) {
+        this.emit('log', chalk.white('[' + document.id + '] ') + chalk.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);
+            generator._typesRoot = path.join(generator._documentRoot, 'models');
+            await generator.generateDocument(ref, { typesOnly: true });
+        }
+    }
+    this._fileHeaderDocInfo = `/*
+ * ${document.info.title}
+ * Id: ${document.id}
+ * Version: ${document.info.version}
+ * ${this.serviceUrl}
+ */`;
+    if (document.types.size) {
+        this.emit('log', chalk.white('[' + document.id + ']'), chalk.cyan(`Processing data types`));
+        for (const t of document.types.values()) {
+            await this.generateDataType(t, 'root');
+        }
+    }
+    if (options?.typesOnly)
+        return out;
+    if (document.api instanceof HttpApi) {
+        await this.generateHttpApi(document.api);
+    }
+    return out;
+}

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

@@ -0,0 +1,40 @@
+import path from 'node:path';
+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 generateHttpApi(api) {
+    let file = this._filesMap.get(api);
+    if (file)
+        return file;
+    const className = api.name ? pascalCase(api.name) : 'Api';
+    file = this.addFile(className + '.ts');
+    file.addImport('@opra/client', ['kClient', 'OpraHttpClient']);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExport('.' + file.filename);
+    const httpApiNodeFile = this.addFile('./http-controller-node.ts');
+    httpApiNodeFile.code.content = httpControllerNodeScript;
+    const classBlock = (file.code[className] = new CodeBlock());
+    classBlock.doc = `/** 
+ * ${wrapJSDocString(api.description || '')}
+ * @class ${className}
+ * @url ${path.posix.join(this.serviceUrl, '$schema')}
+ */`;
+    classBlock.head = `\nexport class ${className} {\n\t`;
+    classBlock.properties = 'readonly [kClient]: OpraHttpClient;';
+    const classConstBlock = (classBlock.classConstBlock = new CodeBlock());
+    classConstBlock.head = `\n\nconstructor(client: OpraHttpClient) {`;
+    classConstBlock.body = `\n\tthis[kClient] = client;`;
+    classConstBlock.tail = `\b\n}\n`;
+    for (const controller of api.controllers.values()) {
+        const generator = this.extend();
+        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));
+        classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+        classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}

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

@@ -0,0 +1,219 @@
+import path from 'node:path';
+import typeIs from '@browsery/type-is';
+import { 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 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}
+ * @url ${path.posix.join(this.serviceUrl, '$schema', '#resources/' + className)}
+ */`;
+    classBlock.head = `\nexport class ${className} extends HttpControllerNode {\n\t`;
+    classBlock.properties = '';
+    const classConstBlock = (classBlock.classConstBlock = new CodeBlock());
+    classConstBlock.head = `\n\nconstructor(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 */
+    for (const operation of controller.operations.values()) {
+        const operationBlock = (classBlock['operation_' + operation.name] = new CodeBlock());
+        operationBlock.doc = `
+/** 
+ * ${wrapJSDocString(operation.description || operation.name + ' operation')}`;
+        if (operation.parameters.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 += block;
+        }
+        operationBlock.doc += `\n */\n`;
+        operationBlock.head = `${operation.name}(`;
+        /** Process operation parameters */
+        const mergedParams = [...controller.parameters, ...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));
+        }
+        let argIndex = 0;
+        for (const prm of pathParams) {
+            let typeName;
+            if (prm.type) {
+                const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                typeName = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            else
+                typeName = `any`;
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += `${prm.name}: ${typeName}`;
+        }
+        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) {
+                    const xt = await this.generateDataType(content.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (typeDef === 'any') {
+                        typeArr = [];
+                        break;
+                    }
+                    if (typeDef) {
+                        if (operation.requestBody.partial) {
+                            file.addImport('ts-gems', ['PartialDTO']);
+                            typeDef = `PartialDTO<${typeDef}>`;
+                        }
+                        else {
+                            file.addImport('ts-gems', ['DTO']);
+                            typeDef = `DTO<${typeDef}>`;
+                        }
+                    }
+                    typeDef = typeDef || 'undefined';
+                    if (!typeArr.includes(typeDef))
+                        typeArr.push(typeDef);
+                    continue;
+                }
+                typeArr = [];
+                break;
+            }
+            operationBlock.head += `$body: ${typeArr.join(' | ') || 'any'}`;
+            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';
+            for (const prm of queryParams) {
+                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);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    operationBlock.head += `${typeDef};\n`;
+                }
+                else
+                    operationBlock.head += `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);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    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 (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;
+}