@opra/cli 0.14.3 → 0.15.0

package/bin/oprimp.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import '../esm/oprimp.js';
+import '../esm/oprimp-cli.js';
 

package/cjs/api-exporter/api-exporter.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExporter = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const node_client_1 = require("@opra/node-client");
+const file_writer_js_1 = require("./file-writer.js");
+const process_resources_js_1 = require("./process-resources.js");
+const process_types_js_1 = require("./process-types.js");
+const ts_file_js_1 = require("./ts-file.js");
+class ApiExporter {
+    constructor(config) {
+        this.files = {};
+        this.client = new node_client_1.OpraHttpClient(config.serviceUrl);
+        this.cwd = config.cwd || node_process_1.default.cwd();
+        this.outDir = node_path_1.default.resolve(this.cwd, config.outDir);
+        this.logger = config.logger || {
+            log: () => void 0,
+            error: () => void 0,
+            debug: () => void 0,
+            warn: () => void 0,
+            verbose: () => void 0,
+        };
+        this.fileHeader = config.fileHeader || '';
+        this.importExt = config.importExt || '';
+        this.writer = config.writer || new file_writer_js_1.FileWriter();
+        // this.nsMap = nsMap || new ResponsiveMap(); // implement references later
+    }
+    async execute() {
+        this.logger.log(chalk_1.default.yellow('Fetching service metadata from'), chalk_1.default.whiteBright(this.client.serviceUrl));
+        this.document = await this.client.getMetadata();
+        this.logger.log(chalk_1.default.yellow('Retrieved service info:\n'), chalk_1.default.white('Title:'), chalk_1.default.magenta(this.document.info.title), '\n', chalk_1.default.white('Version:'), chalk_1.default.magenta(this.document.info.version), '\n', chalk_1.default.white('Resources:'), chalk_1.default.magenta(this.document.resources.size), 'resources found\n', chalk_1.default.white('Types:'), chalk_1.default.magenta(this.document.types.size), 'types found\n');
+        this.name = (this.name || this.document.info.title || 'Service1').replace(/[^\w_$]*/g, '');
+        this.name = this.name.charAt(0).toUpperCase() + this.name.substring(1);
+        this.fileHeader += `/* 
+ * ${this.document.info.title} 
+ * Version ${this.document.info.version}
+ * ${this.client.serviceUrl}
+*/`;
+        this.logger.log(chalk_1.default.yellow('Removing old files..'));
+        this.cleanDirectory(this.outDir);
+        this.logger.log(chalk_1.default.yellow(`Generating service interface ( ${chalk_1.default.whiteBright(this.name)} )`));
+        node_fs_1.default.mkdirSync(this.outDir, { recursive: true });
+        await this.processTypes();
+        await this.processResources();
+        // Write files
+        for (const file of Object.values(this.files)) {
+            const targetDir = node_path_1.default.dirname(file.filename);
+            node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+            await this.writer.writeFile(file.filename, file.generate({ importExt: this.importExt }));
+        }
+    }
+    getFile(filePath) {
+        return this.files[node_path_1.default.resolve(node_path_1.default.join(this.outDir, filePath))];
+    }
+    addFile(filePath, returnExists) {
+        let file = this.getFile(filePath);
+        if (file) {
+            if (returnExists)
+                return file;
+            throw new Error(`File "${filePath}" already exists`);
+        }
+        file = new ts_file_js_1.TsFile(node_path_1.default.resolve(node_path_1.default.join(this.outDir, filePath)));
+        file.header = this.fileHeader;
+        this.files[file.filename] = file;
+        return file;
+    }
+    cleanDirectory(dirname) {
+        if (!node_fs_1.default.existsSync(dirname))
+            return;
+        const files = node_fs_1.default.readdirSync(dirname);
+        for (const f of files) {
+            const absolutePath = node_path_1.default.join(dirname, f);
+            if (node_fs_1.default.statSync(absolutePath).isDirectory()) {
+                this.cleanDirectory(absolutePath);
+                if (!node_fs_1.default.readdirSync(absolutePath).length)
+                    node_fs_1.default.rmdirSync(absolutePath);
+                continue;
+            }
+            if (node_path_1.default.extname(f) === '.ts') {
+                const contents = node_fs_1.default.readFileSync(absolutePath, 'utf-8');
+                if (contents.includes('#!oprimp_auto_generated!#')) {
+                    node_fs_1.default.unlinkSync(absolutePath);
+                }
+            }
+        }
+    }
+    static async execute(config) {
+        const exporter = new ApiExporter(config);
+        await exporter.execute();
+    }
+}
+exports.ApiExporter = ApiExporter;
+(() => {
+    ApiExporter.prototype.processResources = process_resources_js_1.processResources;
+    ApiExporter.prototype.processTypes = process_types_js_1.processTypes;
+    ApiExporter.prototype.generateTypeFile = process_types_js_1.generateTypeFile;
+    ApiExporter.prototype.generateComplexTypeDefinition = process_types_js_1.generateComplexTypeDefinition;
+    ApiExporter.prototype.generateSimpleTypeDefinition = process_types_js_1.generateSimpleTypeDefinition;
+    ApiExporter.prototype.resolveTypeNameOrDef = process_types_js_1.resolveTypeNameOrDef;
+    ApiExporter.prototype.generateEnumTypeDefinition = process_types_js_1.generateEnumTypeDefinition;
+    ApiExporter.prototype.generateUnionTypeDefinition = process_types_js_1.generateUnionTypeDefinition;
+    ApiExporter.prototype.generateMappedTypeDefinition = process_types_js_1.generateMappedTypeDefinition;
+})();

package/cjs/{oprimp → api-exporter}/index.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./generate-service.js"), exports);
+tslib_1.__exportStar(require("./api-exporter.js"), exports);

package/cjs/api-exporter/process-resources.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResources = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const common_1 = require("@opra/common");
+const string_utils_js_1 = require("../utils/string-utils.js");
+/**
+ *
+ * @param targetDir
+ */
+async function processResources(targetDir = '') {
+    this.logger.log(chalk_1.default.yellow('Processing resources'));
+    const { document } = this;
+    const serviceTs = this.addFile(node_path_1.default.join(targetDir, this.name + '.ts'));
+    serviceTs.addImportPackage('@opra/client', ['HttpServiceBase']);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(serviceTs.filename);
+    serviceTs.content = `\nexport class ${this.name} extends HttpServiceBase {\n`;
+    for (const resource of document.resources.values()) {
+        serviceTs.content += `\n/**\n * ${(0, string_utils_js_1.wrapJSDocString)(resource.description || resource.name)}
+ * @url ${(0, common_1.joinPath)(this.client.serviceUrl, '$metadata#resources/' + resource.name)}
+ */`;
+        if (resource instanceof common_1.Collection) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpCollectionNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpCollectionNode<${typeName}>, ${operations}> {
+    return this.$client.collection('${resource.name}');
+  }\n`;
+        }
+        else if (resource instanceof common_1.Singleton) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpSingletonNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpSingletonNode<${typeName}>, ${operations}> {
+    return this.$client.singleton('${resource.name}');
+  }\n`;
+        }
+    }
+    serviceTs.content += '}';
+}
+exports.processResources = processResources;

package/cjs/api-exporter/process-types.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMappedTypeDefinition = exports.generateUnionTypeDefinition = exports.generateEnumTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.resolveTypeNameOrDef = exports.generateTypeFile = exports.processTypes = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const common_1 = require("@opra/common");
+const string_utils_js_1 = require("../utils/string-utils.js");
+const internalTypeNames = ['boolean', 'bigint', 'number', 'null', 'string'];
+/**
+ *
+ * @param targetDir
+ */
+async function processTypes(targetDir = '') {
+    this.logger.log(chalk_1.default.yellow('Processing types'));
+    const { document } = this;
+    const typesTs = this.addFile(node_path_1.default.join(targetDir, 'types.ts'));
+    for (const dataType of document.types.values()) {
+        const expFile = await this.generateTypeFile(dataType, targetDir);
+        typesTs.addExportFile(expFile.filename);
+    }
+}
+exports.processTypes = processTypes;
+/**
+ *
+ * @param dataType
+ * @param targetDir
+ */
+async function generateTypeFile(dataType, targetDir = '') {
+    const typeName = dataType.name;
+    if (!typeName)
+        throw new TypeError(`DataType has no name`);
+    let filePath;
+    if (dataType instanceof common_1.SimpleType)
+        filePath = '/simple-types.ts';
+    else if (dataType instanceof common_1.ComplexType)
+        filePath = `/types/${typeName}.ts`;
+    else if (dataType instanceof common_1.EnumType) {
+        filePath = `/enums/${typeName}.ts`;
+    }
+    else
+        throw new TypeError(`Unimplemented DataType (${dataType.kind})`);
+    const file = this.addFile(node_path_1.default.join(targetDir, filePath), true);
+    if (file.exportTypes.includes(typeName))
+        return file;
+    file.exportTypes.push(typeName);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(file.filename);
+    file.content += `\n/**\n * ${(0, string_utils_js_1.wrapJSDocString)(dataType.description || typeName)}
+ * @type ${typeName}
+ * @kind ${dataType.kind}
+ * @url ${(0, common_1.joinPath)(this.client.serviceUrl, '$metadata#types/' + typeName)}
+ */\n`;
+    if (dataType instanceof common_1.SimpleType) {
+        file.content += `export type ${typeName} = ` + await this.generateSimpleTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof common_1.EnumType) {
+        file.content += `export enum ${typeName} ` + await this.generateEnumTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof common_1.ComplexType) {
+        file.content += `export class ${typeName} {
+  constructor(init?: Partial<I${typeName}>) {
+    if (init)
+     Object.assign(this, init);
+  }
+}
+
+export interface ${typeName} extends I${typeName} {
+}
+
+interface I${typeName} ${await this.generateComplexTypeDefinition(file, dataType, true)}
+`;
+    }
+    return file;
+}
+exports.generateTypeFile = generateTypeFile;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function resolveTypeNameOrDef(file, dataType, forInterface) {
+    if (dataType.name) {
+        if (internalTypeNames.includes(dataType.name))
+            return dataType.name;
+        const f = await this.generateTypeFile(dataType);
+        file.addImportFile(f.filename, [dataType.name]);
+        return dataType.name;
+    }
+    if (dataType instanceof common_1.ComplexType)
+        return this.generateComplexTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof common_1.SimpleType)
+        return this.generateSimpleTypeDefinition(file, dataType);
+    if (dataType instanceof common_1.EnumType)
+        return this.generateEnumTypeDefinition(file, dataType);
+    if (dataType instanceof common_1.UnionType)
+        return this.generateUnionTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof common_1.MappedType)
+        return this.generateMappedTypeDefinition(file, dataType, forInterface);
+    return 'xxx';
+}
+exports.resolveTypeNameOrDef = resolveTypeNameOrDef;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateComplexTypeDefinition(file, dataType, forInterface) {
+    let out = '';
+    if (dataType.base) {
+        const base = await this.resolveTypeNameOrDef(file, dataType.base, forInterface);
+        out += forInterface ? `extends ${base} ` : `${base} & `;
+    }
+    out += '{\n\n\t';
+    for (const field of dataType.own.fields.values()) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (field.description)
+            jsDoc += ` * ${field.description}\n`;
+        if (field.default)
+            jsDoc += ` * @default ` + field.default + '\n';
+        if (field.format)
+            jsDoc += ` * @format ` + field.format + '\n';
+        if (field.exclusive)
+            jsDoc += ` * @exclusive\n`;
+        if (field.deprecated)
+            jsDoc += ` * @deprecated ` + (typeof field.deprecated === 'string' ? field.deprecated : '') + '\n';
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        // Print field name
+        out += `${field.name}${field.required ? '' : '?'}: `;
+        if (field.fixed)
+            out += `${field.fixed}`;
+        else {
+            out += await this.resolveTypeNameOrDef(file, field.type) +
+                `${field.isArray ? '[]' : ''};\n\n`;
+        }
+    }
+    if (dataType.additionalFields)
+        out += '[key: string]: any;\n';
+    return out + '\b}';
+}
+exports.generateComplexTypeDefinition = generateComplexTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+async function generateSimpleTypeDefinition(file, dataType) {
+    if (dataType.ctor === Boolean)
+        return 'boolean';
+    if (dataType.ctor === String)
+        return 'string';
+    if (dataType.ctor === Number)
+        return 'number';
+    if (dataType.ctor === Date)
+        return 'Date';
+    if (dataType.extendsFrom('bigint'))
+        return 'Date';
+    if (dataType.extendsFrom('object'))
+        return 'object';
+    return 'any';
+}
+exports.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+async function generateEnumTypeDefinition(file, dataType) {
+    let out = '{\n\t';
+    for (const [k, v] of Object.entries(dataType.values)) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (dataType.meanings[k])
+            jsDoc += ` * ${dataType.meanings[k]}\n`;
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        out += `${k}`;
+        if (v)
+            out += ' = ' + (typeof v === 'number' ? v : ('"' + ('' + v).replace('"', '\\"')) + '"');
+        out += ',\n\n';
+    }
+    return out + '\b}';
+}
+exports.generateEnumTypeDefinition = generateEnumTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateUnionTypeDefinition(file, dataType, forInterface) {
+    // let out = '';
+    return (await Promise.all(dataType.types
+        .map(t => this.resolveTypeNameOrDef(file, t, forInterface)))).join(forInterface ? ', ' : ' & ');
+}
+exports.generateUnionTypeDefinition = generateUnionTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateMappedTypeDefinition(file, dataType, forInterface) {
+    return (dataType.pick ? 'Pick<' : 'Omit<') +
+        (await this.resolveTypeNameOrDef(file, dataType.type, forInterface)) +
+        ', ' +
+        (dataType.pick || dataType.omit || [])
+            .map(x => `'${x}'`).join(' | ') +
+        '>';
+}
+exports.generateMappedTypeDefinition = generateMappedTypeDefinition;

package/cjs/api-exporter/ts-file.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setExt = exports.relativePath = exports.TsFile = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_flattentext_1 = tslib_1.__importDefault(require("putil-flattentext"));
+class TsFile {
+    constructor(filename) {
+        this.filename = filename;
+        this.importFiles = {};
+        this.exportFiles = {};
+        this.exportTypes = [];
+        this.header = '';
+        this.content = '';
+        this.addImportPackage = (name, types) => {
+            this.importFiles[name] = this.importFiles[name] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[name].includes(x))
+                    this.importFiles[name].push(x);
+            });
+        };
+        this.addImportFile = (filename, types) => {
+            filename = path_1.default.resolve(this.dirname, filename);
+            this.importFiles[filename] = this.importFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[filename].includes(x))
+                    this.importFiles[filename].push(x);
+            });
+        };
+        this.addExportFile = (filename, types) => {
+            filename = path_1.default.resolve(this.dirname, filename);
+            if (filename.endsWith('.ts') || filename.endsWith('.js'))
+                filename = setExt(filename, '');
+            this.exportFiles[filename] = this.exportFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.exportFiles[filename].includes(x))
+                    this.exportFiles[filename].push(x);
+            });
+        };
+        this.dirname = path_1.default.dirname(filename);
+    }
+    generate(options) {
+        const dirname = path_1.default.dirname(this.filename);
+        let output = '/* #!oprimp_auto_generated!# !! Do NOT remove this line */\n' +
+            (this.header ? (0, putil_flattentext_1.default)(this.header) + '\n\n' : '\n');
+        const importStr = Object.keys(this.importFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.importFiles[filename];
+            let relFile = filename;
+            if (path_1.default.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `import ${types.length ? '{' + types.join(', ') + '} from ' : ''}'${relFile}';`;
+        })
+            .join('\n');
+        if (importStr)
+            output += (0, putil_flattentext_1.default)(importStr) + '\n';
+        output += (0, putil_flattentext_1.default)(this.content);
+        const exportStr = Object.keys(this.exportFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.exportFiles[filename];
+            let relFile = filename;
+            if (path_1.default.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `export ${types.length ? '{' + types.join(', ') + '}' : '*'} from '${relFile}';`;
+        })
+            .join('\n');
+        if (exportStr)
+            output += (0, putil_flattentext_1.default)(exportStr) + '\n';
+        return output;
+    }
+}
+exports.TsFile = TsFile;
+function relativePath(from, to) {
+    const s = path_1.default.relative(from, to);
+    return s.startsWith('.') ? s : ('./' + s);
+}
+exports.relativePath = relativePath;
+function setExt(filename, ext) {
+    const e = path_1.default.extname(filename);
+    return filename.substring(0, filename.length - e.length) + (ext ? '.' + ext : '');
+}
+exports.setExt = setExt;

package/cjs/index.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./oprimp/index.js"), exports);
+tslib_1.__exportStar(require("./api-exporter/index.js"), exports);

package/cjs/{oprimp.js → oprimp-cli.js}

@@ -7,9 +7,10 @@ const console = tslib_1.__importStar(require("console"));
 const fs = tslib_1.__importStar(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const process = tslib_1.__importStar(require("process"));
-const generate_service_js_1 = require("./oprimp/generate-service.js");
+const api_exporter_js_1 = require("./api-exporter/api-exporter.js");
 const get_caller_file_util_js_1 = require("./utils/get-caller-file.util.js");
-const pkgJson = JSON.parse(fs.readFileSync(path_1.default.resolve(path_1.default.dirname((0, get_caller_file_util_js_1.getCallerFile)()), '../package.json'), 'utf-8'));
+const dirname = path_1.default.dirname((0, get_caller_file_util_js_1.getCallerFile)());
+const pkgJson = JSON.parse(fs.readFileSync(path_1.default.resolve(dirname, '../package.json'), 'utf-8'));
 commander_1.program
     .version(pkgJson.version)
     .argument('<serviceUrl>', 'OPRA service url')
@@ -20,16 +21,14 @@ commander_1.program
     .action(async (serviceUrl, outDir, options) => {
     if (!options.color)
         chalk_1.default.level = 0;
-    await (0, generate_service_js_1.generateService)({
+    await api_exporter_js_1.ApiExporter.execute({
         serviceUrl,
+        logger: console,
         outDir,
         name: options.name,
-        extension: (options.ext ? '.js' : ''),
-        fileHeader: '/*\n' +
-            ' * Generated by OPRA Service Generator \n' +
-            ' * Version: ' + pkgJson.version + '\n' +
-            ' * ' + new Date() + '\n' +
-            ' */'
+        importExt: (options.ext ? 'js' : ''),
+        fileHeader: '/* Generated by OPRA Service Generator, Version ' + pkgJson.version + '*/\n' +
+            '/* eslint-disable import/extensions,simple-import-sort/imports */\n'
     });
     console.log(chalk_1.default.greenBright('Completed'));
 });

package/esm/api-exporter/api-exporter.d.ts

@@ -0,0 +1,46 @@
+import { ApiDocument } from '@opra/common';
+import { OpraHttpClient } from '@opra/node-client';
+import { IFileWriter } from '../interfaces/file-writer.interface.js';
+import { ILogger } from '../interfaces/logger.interface.js';
+import { processResources } from './process-resources.js';
+import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateSimpleTypeDefinition, generateTypeFile, generateUnionTypeDefinition, processTypes, resolveTypeNameOrDef } from './process-types.js';
+import { TsFile } from './ts-file.js';
+export declare namespace ApiExporter {
+    interface Config {
+        serviceUrl: string;
+        outDir: string;
+        name?: string;
+        cwd?: string;
+        logger?: ILogger;
+        writer?: IFileWriter;
+        fileHeader?: string;
+        importExt?: string;
+    }
+}
+export declare class ApiExporter {
+    protected client: OpraHttpClient;
+    protected document: ApiDocument;
+    protected logger: ILogger;
+    protected outDir: string;
+    protected cwd: string;
+    protected name: string;
+    protected fileHeader: string;
+    protected writer: IFileWriter;
+    protected importExt: string;
+    protected files: Record<string, TsFile>;
+    protected processResources: typeof processResources;
+    protected processTypes: typeof processTypes;
+    protected generateTypeFile: typeof generateTypeFile;
+    protected generateComplexTypeDefinition: typeof generateComplexTypeDefinition;
+    protected generateSimpleTypeDefinition: typeof generateSimpleTypeDefinition;
+    protected resolveTypeNameOrDef: typeof resolveTypeNameOrDef;
+    protected generateEnumTypeDefinition: typeof generateEnumTypeDefinition;
+    protected generateUnionTypeDefinition: typeof generateUnionTypeDefinition;
+    protected generateMappedTypeDefinition: typeof generateMappedTypeDefinition;
+    protected constructor(config: ApiExporter.Config);
+    protected execute(): Promise<void>;
+    protected getFile(filePath: string): TsFile;
+    protected addFile(filePath: string, returnExists?: boolean): TsFile;
+    protected cleanDirectory(dirname: string): void;
+    static execute(config: ApiExporter.Config): Promise<void>;
+}

package/esm/api-exporter/api-exporter.js

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { OpraHttpClient } from '@opra/node-client';
+import { FileWriter } from './file-writer.js';
+import { processResources } from './process-resources.js';
+import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateSimpleTypeDefinition, generateTypeFile, generateUnionTypeDefinition, processTypes, resolveTypeNameOrDef } from './process-types.js';
+import { TsFile } from './ts-file.js';
+export class ApiExporter {
+    constructor(config) {
+        this.files = {};
+        this.client = new OpraHttpClient(config.serviceUrl);
+        this.cwd = config.cwd || process.cwd();
+        this.outDir = path.resolve(this.cwd, config.outDir);
+        this.logger = config.logger || {
+            log: () => void 0,
+            error: () => void 0,
+            debug: () => void 0,
+            warn: () => void 0,
+            verbose: () => void 0,
+        };
+        this.fileHeader = config.fileHeader || '';
+        this.importExt = config.importExt || '';
+        this.writer = config.writer || new FileWriter();
+        // this.nsMap = nsMap || new ResponsiveMap(); // implement references later
+    }
+    async execute() {
+        this.logger.log(chalk.yellow('Fetching service metadata from'), chalk.whiteBright(this.client.serviceUrl));
+        this.document = await this.client.getMetadata();
+        this.logger.log(chalk.yellow('Retrieved service info:\n'), chalk.white('Title:'), chalk.magenta(this.document.info.title), '\n', chalk.white('Version:'), chalk.magenta(this.document.info.version), '\n', chalk.white('Resources:'), chalk.magenta(this.document.resources.size), 'resources found\n', chalk.white('Types:'), chalk.magenta(this.document.types.size), 'types found\n');
+        this.name = (this.name || this.document.info.title || 'Service1').replace(/[^\w_$]*/g, '');
+        this.name = this.name.charAt(0).toUpperCase() + this.name.substring(1);
+        this.fileHeader += `/* 
+ * ${this.document.info.title} 
+ * Version ${this.document.info.version}
+ * ${this.client.serviceUrl}
+*/`;
+        this.logger.log(chalk.yellow('Removing old files..'));
+        this.cleanDirectory(this.outDir);
+        this.logger.log(chalk.yellow(`Generating service interface ( ${chalk.whiteBright(this.name)} )`));
+        fs.mkdirSync(this.outDir, { recursive: true });
+        await this.processTypes();
+        await this.processResources();
+        // Write files
+        for (const file of Object.values(this.files)) {
+            const targetDir = path.dirname(file.filename);
+            fs.mkdirSync(targetDir, { recursive: true });
+            await this.writer.writeFile(file.filename, file.generate({ importExt: this.importExt }));
+        }
+    }
+    getFile(filePath) {
+        return this.files[path.resolve(path.join(this.outDir, filePath))];
+    }
+    addFile(filePath, returnExists) {
+        let file = this.getFile(filePath);
+        if (file) {
+            if (returnExists)
+                return file;
+            throw new Error(`File "${filePath}" already exists`);
+        }
+        file = new TsFile(path.resolve(path.join(this.outDir, filePath)));
+        file.header = this.fileHeader;
+        this.files[file.filename] = file;
+        return file;
+    }
+    cleanDirectory(dirname) {
+        if (!fs.existsSync(dirname))
+            return;
+        const files = fs.readdirSync(dirname);
+        for (const f of files) {
+            const absolutePath = path.join(dirname, f);
+            if (fs.statSync(absolutePath).isDirectory()) {
+                this.cleanDirectory(absolutePath);
+                if (!fs.readdirSync(absolutePath).length)
+                    fs.rmdirSync(absolutePath);
+                continue;
+            }
+            if (path.extname(f) === '.ts') {
+                const contents = fs.readFileSync(absolutePath, 'utf-8');
+                if (contents.includes('#!oprimp_auto_generated!#')) {
+                    fs.unlinkSync(absolutePath);
+                }
+            }
+        }
+    }
+    static async execute(config) {
+        const exporter = new ApiExporter(config);
+        await exporter.execute();
+    }
+}
+(() => {
+    ApiExporter.prototype.processResources = processResources;
+    ApiExporter.prototype.processTypes = processTypes;
+    ApiExporter.prototype.generateTypeFile = generateTypeFile;
+    ApiExporter.prototype.generateComplexTypeDefinition = generateComplexTypeDefinition;
+    ApiExporter.prototype.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
+    ApiExporter.prototype.resolveTypeNameOrDef = resolveTypeNameOrDef;
+    ApiExporter.prototype.generateEnumTypeDefinition = generateEnumTypeDefinition;
+    ApiExporter.prototype.generateUnionTypeDefinition = generateUnionTypeDefinition;
+    ApiExporter.prototype.generateMappedTypeDefinition = generateMappedTypeDefinition;
+})();

package/esm/api-exporter/index.d.ts

@@ -0,0 +1 @@
+export * from './api-exporter.js';