@opra/cli 0.33.11 → 1.0.0-alpha.7

package/bin/bin/oprimp.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
+/* eslint-disable import-x/no-unresolved */
 import '../esm/oprimp-cli.js';
-

package/bin/oprimp.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
+/* eslint-disable import-x/no-unresolved */
 import '../esm/oprimp-cli.js';
-

package/cjs/code-block.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBlock = void 0;
+class CodeBlock {
+    toString() {
+        // if (this.content) return this.content;
+        let out = '';
+        for (const x of Object.values(this)) {
+            out += String(x);
+        }
+        return out;
+    }
+    [Symbol.toStringTag]() {
+        return this.toString();
+    }
+}
+exports.CodeBlock = CodeBlock;

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("./api-exporter/api-exporter.js"), exports);
+tslib_1.__exportStar(require("./ts-generator/index.js"), exports);

package/cjs/oprimp-cli.js

@@ -7,29 +7,29 @@ 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 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 dirname = path_1.default.dirname((0, get_caller_file_util_js_1.getCallerFile)());
+const common_1 = require("@opra/common");
+const ts_generator_js_1 = require("./ts-generator/ts-generator.js");
+const dirname = path_1.default.dirname((0, common_1.getStackFileName)());
 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')
     .argument('<outDir>', 'Output directory')
-    .option('--name <name>', 'Name of the service')
     .option('--ext', 'Adds js extension to imports')
     .option('--no-color', 'Disables colors in logs messages')
     .action(async (serviceUrl, outDir, options) => {
     if (!options.color)
         chalk_1.default.level = 0;
-    await api_exporter_js_1.ApiExporter.execute({
+    const generator = new ts_generator_js_1.TsGenerator({
         serviceUrl,
         logger: console,
         outDir,
-        name: options.name,
         importExt: options.ext,
-        fileHeader: '/* Generated by OPRA Service Generator, Version ' + pkgJson.version + '*/\n' +
-            '/* eslint-disable */\n'
-    }).then(() => console.log(chalk_1.default.greenBright('Completed')))
+        fileHeader: `/* Generated by OPRA Code Generator, Version ${pkgJson.version} */`,
+    });
+    await generator
+        .generate()
+        .then(() => console.log(chalk_1.default.greenBright('Completed')))
         .catch(e => console.error(e.message));
 });
 if (process.argv.length < 3)

package/cjs/ts-generator/http-controller-node.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpControllerNodeScript = void 0;
+exports.httpControllerNodeScript = `import { kClient, OpraHttpClient } from '@opra/client';
+
+const PARAM_PATTERN = /:\\w+/g;
+
+export class HttpControllerNode {
+  readonly [kClient]: OpraHttpClient;
+
+  constructor(client: OpraHttpClient) {
+    this[kClient] = client;
+  }
+  
+  protected _prepareUrl(url: string, params: Record<string, any>): string {
+    return url.replace(PARAM_PATTERN, s => {
+      return params[s.substring(1)] || '';
+    });
+  }
+}
+`;

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

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

package/cjs/ts-generator/processors/clean-directory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanDirectory = 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"));
+function cleanDirectory(dirname) {
+    const rootDir = dirname;
+    const _cleanDirectory = (targetDir) => {
+        if (!node_fs_1.default.existsSync(targetDir))
+            return;
+        const files = node_fs_1.default.readdirSync(targetDir);
+        for (const f of files) {
+            const absolutePath = node_path_1.default.join(targetDir, f);
+            if (node_fs_1.default.statSync(absolutePath).isDirectory()) {
+                _cleanDirectory(absolutePath);
+                if (!node_fs_1.default.readdirSync(absolutePath).length) {
+                    this.emit('verbose', chalk_1.default.cyan(`Removing directory ${node_path_1.default.relative(absolutePath, rootDir)}`));
+                    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!#')) {
+                    this.emit('verbose', chalk_1.default.cyan(`Removing file ${node_path_1.default.relative(absolutePath, rootDir)}`));
+                    node_fs_1.default.unlinkSync(absolutePath);
+                }
+            }
+        }
+    };
+    _cleanDirectory(dirname);
+}
+exports.cleanDirectory = cleanDirectory;

package/cjs/ts-generator/processors/process-data-types.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypeNameOrDef = exports.generateMappedTypeDefinition = exports.generateMixinTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.generateEnumTypeDefinition = exports.processDataType = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const common_1 = require("@opra/common");
+const code_block_js_1 = require("../../code-block.js");
+const string_utils_js_1 = require("../utils/string-utils.js");
+const internalTypeNames = ['any', 'boolean', 'bigint', 'number', 'null', 'string', 'object'];
+async function processDataType(dataType) {
+    const doc = dataType.node.getDocument();
+    if (doc.id !== this._document?.id) {
+        const { generator } = await this.processDocument(doc);
+        return await generator.processDataType(dataType);
+    }
+    const typeName = dataType.name;
+    if (typeName && internalTypeNames.includes(typeName))
+        return;
+    if (!typeName)
+        throw new TypeError(`DataType has no name`);
+    let file = this._filesMap.get(dataType);
+    if (file)
+        return file;
+    if (dataType instanceof common_1.SimpleType)
+        file = this.addFile(path_1.default.join(this._documentRoot, '/simple-types.ts'), true);
+    else {
+        if (dataType instanceof common_1.EnumType)
+            file = this.addFile(path_1.default.join(this._typesRoot, 'enums', typeName + '.ts'));
+        else
+            file = this.addFile(path_1.default.join(this._typesRoot, 'types', typeName + '.ts'));
+    }
+    this._filesMap.set(dataType, file);
+    file = this._filesMap.get(dataType);
+    if (file.exportTypes.includes(typeName))
+        return file;
+    file.exportTypes.push(typeName);
+    const typesIndexTs = this.addFile(path_1.default.join(this._typesRoot, 'index.ts'), true);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExport(typesIndexTs.filename);
+    const codeBlock = (file.code['type_' + typeName] = new code_block_js_1.CodeBlock());
+    codeBlock.head = `/**\n * ${typeName}`;
+    if (dataType.description)
+        codeBlock.head += `\n * ${(0, string_utils_js_1.wrapJSDocString)(dataType.description || '')}`;
+    codeBlock.head += `
+ * @url ${path_1.default.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
+ */
+export `;
+    if (dataType instanceof common_1.EnumType)
+        codeBlock.typeDef = await this.generateEnumTypeDefinition(dataType, 'scope');
+    else if (dataType instanceof common_1.ComplexType)
+        codeBlock.typeDef = await this.generateComplexTypeDefinition(dataType, file, 'scope');
+    else if (dataType instanceof common_1.SimpleType)
+        codeBlock.typeDef = await this.generateSimpleTypeDefinition(dataType, 'scope');
+    else if (dataType instanceof common_1.MappedType)
+        codeBlock.typeDef = await this.generateMappedTypeDefinition(dataType, file, 'scope');
+    else if (dataType instanceof common_1.MixinType)
+        codeBlock.typeDef = await this.generateMixinTypeDefinition(dataType, file, 'scope');
+    else
+        throw new TypeError(`${dataType.kind} data type (${typeName}) can not be directly exported`);
+    typesIndexTs.addExport(file.filename);
+    return file;
+}
+exports.processDataType = processDataType;
+/**
+ *
+ */
+async function generateEnumTypeDefinition(dataType, intent) {
+    if (intent === 'field')
+        return ('(' +
+            Object.keys(dataType.attributes)
+                .map(t => `'${t}'`)
+                .join(' | ') +
+            ')');
+    if (intent !== 'scope')
+        throw new TypeError(`Can't generate EnumType for "${intent}" intent`);
+    if (!dataType.name)
+        throw new TypeError(`Name required to generate EnumType for "${intent}" intent`);
+    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}';
+}
+exports.generateEnumTypeDefinition = generateEnumTypeDefinition;
+/**
+ *
+ */
+async function generateComplexTypeDefinition(dataType, file, intent) {
+    if (intent === 'scope' && !dataType.name)
+        throw new TypeError(`Name required to generate ComplexType for "${intent}" intent`);
+    let out = intent === 'scope' ? `interface ${dataType.name} ` : '';
+    const ownFields = [...dataType.fields.values()].filter(f => f.origin === dataType);
+    if (dataType.base) {
+        const base = await this.resolveTypeNameOrDef(dataType.base, file, 'extends');
+        const omitBaseFields = dataType.base ? ownFields.filter(f => dataType.base.fields.has(f.name)) : [];
+        const baseDef = omitBaseFields.length
+            ? `Omit<${base}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`
+            : `${base}`;
+        if (intent === 'scope')
+            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 {
+            out += (await this.resolveTypeNameOrDef(field.type, file, 'field')) + `${field.isArray ? '[]' : ''};\n`;
+        }
+    }
+    if (dataType.additionalFields)
+        out += '[key: string]: any;\n';
+    return out + '\b}';
+}
+exports.generateComplexTypeDefinition = generateComplexTypeDefinition;
+/**
+ *
+ */
+async function generateSimpleTypeDefinition(dataType, intent) {
+    if (intent === 'scope' && !dataType.name)
+        throw new TypeError(`Name required to generate SimpleType for "${intent}" intent`);
+    let out = intent === 'scope' ? `type ${dataType.name} = ` : '';
+    out += dataType.nameMappings.js || 'any';
+    return intent === 'scope' ? out + ';' : out;
+}
+exports.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
+/**
+ *
+ */
+async function generateMixinTypeDefinition(dataType, file, intent) {
+    return (await Promise.all(dataType.types.map(t => this.resolveTypeNameOrDef(t, file, intent))))
+        .map(t => (t.includes('|') ? '(' + t + ')' : t))
+        .join(intent === 'extends' ? ', ' : ' & ');
+}
+exports.generateMixinTypeDefinition = generateMixinTypeDefinition;
+/**
+ *
+ */
+async function generateMappedTypeDefinition(dataType, file, intent) {
+    const typeDef = await this.resolveTypeNameOrDef(dataType.base, file, intent);
+    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;
+    let out = '';
+    if (partial === true)
+        out += 'Partial<';
+    else if (partial) {
+        out += 'PartialSome<';
+        file.addExport('ts-gems', ['PartialSome']);
+    }
+    if (required === true)
+        out += 'Partial<';
+    else if (required) {
+        out += 'RequiredSome<';
+        file.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;
+}
+exports.generateMappedTypeDefinition = generateMappedTypeDefinition;
+/**
+ *
+ */
+async function resolveTypeNameOrDef(dataType, file, intent) {
+    if (dataType.name && !dataType.embedded) {
+        if (internalTypeNames.includes(dataType.name))
+            return dataType.name;
+        const f = await this.processDataType(dataType);
+        if (!f)
+            return '';
+        file.addImport(f.filename, [dataType.name], true);
+        return dataType.name;
+    }
+    if (dataType instanceof common_1.SimpleType)
+        return this.generateSimpleTypeDefinition(dataType, intent);
+    if (dataType instanceof common_1.EnumType)
+        return this.generateEnumTypeDefinition(dataType, intent);
+    if (dataType instanceof common_1.MixinType)
+        return this.generateMixinTypeDefinition(dataType, file, intent);
+    if (dataType instanceof common_1.MappedType)
+        return this.generateMappedTypeDefinition(dataType, file, intent);
+    if (dataType instanceof common_1.ComplexType)
+        return this.generateComplexTypeDefinition(dataType, file, intent);
+    return '';
+}
+exports.resolveTypeNameOrDef = resolveTypeNameOrDef;

package/cjs/ts-generator/processors/process-document.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDocument = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const client_1 = require("@opra/client");
+const common_1 = require("@opra/common");
+async function processDocument(document, options) {
+    if (!document || typeof document === 'string') {
+        if (document) {
+            const out = this._documentsMap.get(document);
+            if (out)
+                return out;
+        }
+        this.emit('log', chalk_1.default.cyan('Fetching document schema from ') + chalk_1.default.blueBright(this.serviceUrl));
+        const client = new client_1.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_1.default.white('[' + document.id + '] ') + chalk_1.default.cyan('Processing document ') + chalk_1.default.magenta(document.info.title));
+    if (document.references.size) {
+        this.emit('log', chalk_1.default.white('[' + document.id + '] ') + chalk_1.default.cyan(`Processing references`));
+        for (const ref of document.references.values()) {
+            const generator = this.extend();
+            generator._document = ref;
+            generator._documentRoot = '/references/' + (ref.info.title ? (0, putil_varhelpers_1.pascalCase)(ref.info.title) : ref.id);
+            generator._typesRoot = path_1.default.join(generator._documentRoot, 'models');
+            await generator.processDocument(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_1.default.white('[' + document.id + ']'), chalk_1.default.cyan(`Processing data types`));
+        for (const t of document.types.values()) {
+            await this.processDataType(t);
+        }
+    }
+    if (options?.typesOnly)
+        return out;
+    if (document.api instanceof common_1.HttpApi) {
+        await this.processHttpApi(document.api);
+    }
+    return out;
+}
+exports.processDocument = processDocument;

package/cjs/ts-generator/processors/process-http-api.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processHttpApi = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const code_block_js_1 = require("../../code-block.js");
+const http_controller_node_js_1 = require("../http-controller-node.js");
+const string_utils_js_1 = require("../utils/string-utils.js");
+async function processHttpApi(api) {
+    let file = this._filesMap.get(api);
+    if (file)
+        return file;
+    const className = api.name ? (0, putil_varhelpers_1.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 = http_controller_node_js_1.httpControllerNodeScript;
+    const classBlock = (file.code[className] = new code_block_js_1.CodeBlock());
+    classBlock.doc = `/** 
+ * ${(0, string_utils_js_1.wrapJSDocString)(api.description || '')}
+ * @class ${className}
+ * @url ${node_path_1.default.posix.join(this.serviceUrl, '$schema')}
+ */`;
+    classBlock.head = `\nexport class ${className} {\n\t`;
+    classBlock.properties = 'readonly [kClient]: OpraHttpClient;';
+    const classConstBlock = (classBlock.classConstBlock = new code_block_js_1.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.processHttpController(controller);
+        const childClassName = (0, putil_varhelpers_1.pascalCase)(controller.name) + 'Controller';
+        file.addImport('.' + f.filename, [childClassName]);
+        const property = '$' + controller.name.charAt(0).toLowerCase() + (0, putil_varhelpers_1.camelCase)(controller.name.substring(1));
+        classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+        classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}
+exports.processHttpApi = processHttpApi;