@open-norantec/herbal 1.0.2-alpha.2 → 1.0.2-alpha.21

package/dist/abstracts/client.abstract.class.d.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+import { Constructor } from 'type-fest';
+import { OpenAPIObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
+export interface CreateClientOptions {
+    Module: Constructor<any>;
+}
+export declare abstract class Client {
+    readonly options: CreateClientOptions;
+    protected document: OpenAPIObject;
+    constructor(options: CreateClientOptions);
+    abstract generateClientSourceFile(): string;
+    createSchema(group?: string): void;
+}

package/dist/abstracts/client.abstract.class.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+require("reflect-metadata");
+var nest_util_class_1 = require("../utilities/nest-util.class");
+var string_util_class_1 = require("@open-norantec/utilities/dist/string-util.class");
+var controller_util_class_1 = require("../utilities/controller-util.class");
+var method_decorator_1 = require("../decorators/method.decorator");
+var Client = (function () {
+    function Client(options) {
+        this.options = options;
+        this.document = {
+            openapi: '3.1.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+            },
+            paths: {},
+        };
+    }
+    Client.prototype.createSchema = function (group) {
+        var _this = this;
+        if (string_util_class_1.StringUtil.isFalsyString(group) && typeof group !== 'undefined')
+            return;
+        nest_util_class_1.NestUtil.getControllerClasses(this.options.Module).forEach(function (Class) {
+            if (string_util_class_1.StringUtil.isFalsyString(Class === null || Class === void 0 ? void 0 : Class.name) || !(0, controller_util_class_1.isHerbalController)(Class))
+                return;
+            var controllerName = (0, controller_util_class_1.getControllerName)(Class);
+            var pool = method_decorator_1.Method.getPool(Class.prototype);
+            if (string_util_class_1.StringUtil.isFalsyString(controllerName) || pool === null)
+                return;
+            Object.entries(pool.getOpenAPIPathsObject(group)).forEach(function (_a) {
+                var pathname = _a[0], schemas = _a[1];
+                _this.document.paths[["/".concat(controllerName), pathname].join('')] = schemas;
+            });
+        });
+    };
+    return Client;
+}());
+exports.Client = Client;

package/dist/abstracts/index.d.ts

@@ -1 +1,2 @@
 export * from './auth-adapter.abstract.class';
+export * from './client.abstract.class';

package/dist/abstracts/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-adapter.abstract.class"), exports);
+__exportStar(require("./client.abstract.class"), exports);

package/dist/cli/herbal.js

@@ -3,16 +3,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
 var forge_1 = require("@open-norantec/forge");
+var _ = require("lodash");
+var fs = require("fs-extra");
+var path = require("node:path");
+var requireFromString = require("require-from-string");
+var reflect_declaration_1 = require("../transformers/reflect-declaration");
 var command = new commander_1.Command('herbal');
-var getEntryFileContent = function (_a) {
-    var entryFilePath = _a.entryFilePath;
+var log = function (level) {
+    var _a, _b;
+    var messages = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        messages[_i - 1] = arguments[_i];
+    }
+    console.log("[".concat(new Date().toISOString(), "] -").concat(level, "- ").concat((_b = (_a = messages === null || messages === void 0 ? void 0 : messages.join) === null || _a === void 0 ? void 0 : _a.call(messages, ' ')) !== null && _b !== void 0 ? _b : ''));
+    switch (level) {
+        case 'error':
+            process.exit(1);
+        default:
+            break;
+    }
+};
+var handleGetVirtualEntryFileContent = function (buildEntryFilePath) {
     return [
         "import 'reflect-metadata';",
-        "import { ModelUtil, NestFactory } from '@open-norantec/herbal';",
+        "import { ModelUtil, NestFactory, isApplication } from '@open-norantec/herbal';",
         "import { LoggerService } from '@open-norantec/herbal/dist/modules/logger/logger.service';",
         "import { Worker, isMainThread, workerData } from 'node:worker_threads';",
-        "import ENTRY from '".concat(entryFilePath, "';"),
+        "import ENTRY from '".concat(buildEntryFilePath, "';"),
         '\nasync function bootstrap() {',
+        '  if (!isApplication(ENTRY)) {',
+        '    console.log(`The entry file must export an application or a function that returns an application.`);',
+        '    process.exit(1);',
+        '  }',
         '  const entryOptions = ENTRY?.options;',
         '  await entryOptions?.onBeforeBootstrap?.();',
         "\n  if (!!workerData?.['__herbal_worker']) {",
@@ -67,74 +89,110 @@ var getEntryFileContent = function (_a) {
         '\nbootstrap();',
     ].join('\n');
 };
-var getGenerateClientEntryFileContent = function (_a) {
-    var entryFilePath = _a.entryFilePath, outputPath = _a.outputPath, options = _a.options;
-    return [
-        "import 'reflect-metadata';",
-        "import ENTRY from '".concat(entryFilePath, "';"),
-        "import * as fs from 'node:fs';",
-        "import * as path from 'node:path';",
-        '\nasync function bootstrap() {',
-        "  const outputDirPath = '".concat(outputPath, "';"),
-        "  const outputFilePath = path.resolve(outputDirPath, '".concat(options.outputName, ".ts');"),
-        '  await ENTRY?.options?.onBeforeBootstrap?.();',
-        '  try {',
-        '    fs.rmSync(outputFilePath, {',
-        '      recursive: true,',
-        '      force: true,',
-        '    });',
-        '  } catch {}',
-        '  try {',
-        '    if (!fs.statSync(path.dirname(outputDirPath)).isDirectory()) {',
-        '      fs.rmSync(path.dirname(outputDirPath), {',
-        '        recursive: true,',
-        '        force: true,',
-        '      });',
-        '    }',
-        '  } catch {}',
-        '  try {',
-        '    fs.mkdirSync(outputDirPath, { recursive: true });',
-        '  } catch {}',
-        '  fs.writeFileSync(',
-        '    outputFilePath,',
-        '    ENTRY?.generateClientSourceFile?.(),',
-        '  );',
-        '}',
-        '\nbootstrap();',
-    ].join('\n');
-};
-var handleLog = function (level, message) {
-    console.log("[".concat(new Date().toISOString(), "] [").concat(level, "] ").concat(message));
-    switch (level) {
-        case 'error':
-            process.exit(1);
-        default:
-            break;
+var handleGetFileContent = function (filePath) {
+    var content = _.attempt(function () { return fs.readFileSync(filePath, 'utf-8'); });
+    if (content instanceof Error) {
+        log('error', "Failed to read file content for ".concat(filePath, ":"), content.message);
+        return '';
     }
+    return content;
+};
+var handleGetWatcher = function (callback) {
+    var watcher = fs.watch(process.cwd(), { recursive: true }, function (eventType, filename) {
+        callback(path.resolve(filename));
+    });
+    return { close: watcher.close.bind(watcher) };
 };
+var createHandleOutputFile = function (disableWriteFile) { return function (filePath, content) {
+    if (!disableWriteFile) {
+        var dir_1 = path.dirname(filePath);
+        if (!fs.existsSync(dir_1) || !fs.statSync(dir_1).isDirectory()) {
+            _.attempt(function () { return fs.removeSync(dir_1); });
+            _.attempt(function () { return fs.mkdirpSync(dir_1); });
+        }
+        _.attempt(function () { return fs.writeFileSync(filePath, content, 'utf-8'); });
+        log('info', "Generated file: ".concat(filePath));
+    }
+}; };
 command
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler', '--mode'],
-    mode: 'production',
-    afterEmitAction: 'none',
-}).name('build'))
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler'],
-    mode: 'development',
-    afterEmitAction: 'watch',
-}).name('watch'))
-    .addCommand((0, forge_1.createForgeCommand)({
-    onLog: handleLog,
-    getEntryFileContent: getGenerateClientEntryFileContent,
-    hideOptions: ['--after-emit-action', '--ts-compiler', '--mode'],
-    mode: 'production',
-    afterEmitAction: 'run-once',
-    tsCompiler: require.resolve('ts-patch/compiler', {
-        paths: [__dirname, process.cwd()],
-    }),
-}).name('generate-client'));
+    .addCommand((0, forge_1.createCommand)('build', {
+    hiddenOptions: ['--watch', '--execute-after-build'],
+    onLog: log,
+    defaultOptions: function (source, output, options) { return ({
+        getWatcher: handleGetWatcher,
+        getVirtualEntryFileContent: handleGetVirtualEntryFileContent,
+        onGetFileContent: handleGetFileContent,
+        onOutputFile: createHandleOutputFile(!!(options === null || options === void 0 ? void 0 : options.disableWriteFile)),
+    }); },
+}))
+    .addCommand((0, forge_1.createCommand)('watch', {
+    hiddenOptions: [
+        '--watch',
+        '--execute-after-build',
+        '--obfuscate',
+        '--obfuscator-config-file <string>',
+        '--disable-write-file',
+    ],
+    onLog: log,
+    defaultOptions: function () { return ({
+        watch: true,
+        executeAfterBuild: true,
+        obfuscate: false,
+        getWatcher: handleGetWatcher,
+        getVirtualEntryFileContent: handleGetVirtualEntryFileContent,
+        onGetFileContent: handleGetFileContent,
+        onOutputFile: createHandleOutputFile(true),
+    }); },
+}))
+    .addCommand((0, forge_1.createCommand)('generate-client', function (_a) {
+    var addOption = _a.addOption;
+    addOption('--group <name>', 'Client group name to generate');
+    return {
+        onLog: log,
+        hiddenOptions: [
+            '--watch',
+            '--execute-after-build',
+            '--obfuscate',
+            '--obfuscator-config-file <string>',
+            '--disable-write-file',
+        ],
+        defaultOptions: function (source, output, options) { return ({
+            watch: false,
+            executeAfterBuild: false,
+            obfuscate: false,
+            customTransformers: function (program) {
+                return {
+                    before: [(0, reflect_declaration_1.transformer)(program)],
+                };
+            },
+            getWatcher: handleGetWatcher,
+            onGetFileContent: handleGetFileContent,
+            onOutputFile: createHandleOutputFile(false),
+            getVirtualEntryFileContent: function (buildEntryFilePath) {
+                return [
+                    "const entry = require('".concat(buildEntryFilePath, "')"),
+                    "const { isClient } = require(\'@open-norantec/herbal\')",
+                    'module.exports = (context) => {',
+                    '  let client = entry;',
+                    '  if (!isClient(client)) { client = entry?.default; }',
+                    "  if (!isClient(client)) return '';",
+                    '  client.instance.createSchema(context?.group);',
+                    "  return client.instance.generateClientSourceFile() ?? '';",
+                    '};',
+                ].join('\n');
+            },
+            rewriteOutputFile: function (code) {
+                try {
+                    var generateCodeMethod = requireFromString(code);
+                    if (typeof generateCodeMethod !== 'function')
+                        return '';
+                    return generateCodeMethod({ group: options === null || options === void 0 ? void 0 : options.group });
+                }
+                catch (_a) {
+                    return '';
+                }
+            },
+        }); },
+    };
+}));
 command.parse(process.argv);

package/dist/clients/index.d.ts

@@ -0,0 +1 @@
+export * from './typescript-client.class';

package/dist/clients/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./typescript-client.class"), exports);

package/dist/clients/typescript-client.class.d.ts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+import { SchemaObject } from 'zod-openapi/dist/openapi3-ts/dist/model/openapi31';
+import { Client, CreateClientOptions } from '../abstracts/client.abstract.class';
+declare namespace OpenApiToTypescript {
+    interface Options {
+        useInterface?: boolean;
+        export?: boolean;
+        generateJSDoc?: boolean;
+        preferUnknown?: boolean;
+        singleLine?: boolean;
+    }
+    interface TypeResult {
+        code: string;
+        name?: string;
+    }
+}
+export declare function convertOpenApiToTypescript(schema: SchemaObject, name?: string, options?: OpenApiToTypescript.Options): OpenApiToTypescript.TypeResult;
+export declare class TypeScriptClient extends Client implements Client {
+    constructor(options: CreateClientOptions);
+    generateClientSourceFile(): string;
+}
+export {};