org-core-js 0.0.1

package/cjs/core/index.js

@@ -0,0 +1,477 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _serviceCore = _interopRequireDefault(require("./serviceCore.js"));
+var _workerCore = _interopRequireDefault(require("./workerCore.js"));
+var _repositoryCore = _interopRequireDefault(require("./repositoryCore.js"));
+var _serverCore = _interopRequireDefault(require("./serverCore.js"));
+var _driverCore = _interopRequireDefault(require("./driverCore.js"));
+var _entityCore = _interopRequireDefault(require("./entityCore.js"));
+var _utilCore = _interopRequireDefault(require("./utilCore.js"));
+var _libCore = _interopRequireDefault(require("./libCore.js"));
+var _eventCore = _interopRequireDefault(require("./eventCore.js"));
+var _forawait = _interopRequireDefault(require("../forawait.js"));
+var _fileCore = _interopRequireDefault(require("../fileCore.js"));
+var _nodeEvents = require("node:events");
+var _nodeCrypto = _interopRequireDefault(require("node:crypto"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const eventCore = new _nodeEvents.EventEmitter();
+const libCore = {
+  forawait: _forawait.default,
+  generate: {
+    string(length = 25) {
+      let result = '';
+      const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+      const charactersLength = characters.length;
+      let counter = 0;
+      while (counter < length) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        counter += 1;
+      }
+      return result;
+    },
+    number(length = 25) {
+      let result = '';
+      const characters = '0123456789';
+      const charactersLength = characters.length;
+      let counter = 0;
+      while (counter < length) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        counter += 1;
+      }
+      return result;
+    },
+    keys({
+      type,
+      modulusLength = 4096
+    }) {
+      return new Promise((resolve, reject) => {
+        _nodeCrypto.default.generateKeyPair('rsa', {
+          modulusLength,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          }
+        }, (err, publicKey, privateKey) => {
+          if (err) return reject(err);
+          resolve({
+            public: publicKey,
+            private: privateKey
+          });
+        });
+      });
+    }
+  }
+};
+const ioCore = {
+  client: [],
+  server: []
+};
+const utilCore = {};
+const services = {};
+const repositoryCore = {};
+const entityCore = {};
+const methodCore = {
+  node: {
+    pub({
+      topic
+    }, ...input) {
+      eventCore.emit(topic, ...input);
+    },
+    sub({
+      topic
+    }, fn = console.log) {
+      eventCore.on(topic, fn);
+    }
+  }
+};
+var _default = ({}) => {
+  const app = {
+    service: (params = '') => {
+      const [service_, method] = params.split('.');
+      return {
+        async execute(input, event) {
+          const output = await services[service_][method](input, event);
+          if (!event) return output;
+          methodCore[event].pub({
+            topic: 'service::' + service_ + '.' + method
+          }, output);
+          return output;
+        }
+      };
+    },
+    driver: (params = '') => {
+      return methodCore[params];
+    },
+    lib: (params = '') => {
+      return libCore[params];
+    },
+    nats: (name = "nats") => {
+      return libCore[name];
+    },
+    util: (params = '') => {
+      return utilCore[params];
+    },
+    entity: (params = '') => {
+      const [entity_, method] = params.split('.');
+      if (method) {
+        return {
+          async execute(input, event) {
+            const output = await entityCore[entity_][method](input);
+            if (!event) return output;
+            methodCore[event].pub({
+              topic: 'entity::' + entity_ + '.' + method
+            }, output);
+            return output;
+          }
+        };
+      }
+      return {
+        async entity(input, event) {
+          const output = await entityCore[entity_]["entity"](input);
+          if (!event) return output;
+          methodCore[event].pub({
+            topic: 'entity::' + entity_ + '.' + method
+          }, output);
+          return output;
+        },
+        async dto(input) {
+          const output = await entityCore[entity_]["dto"](input);
+          return output;
+        }
+      };
+    },
+    repository: (params = '') => {
+      const [repository_, method] = params.split('.');
+      return {
+        async execute(input, event) {
+          const output = await repositoryCore[repository_][method](input);
+          if (!event) return output;
+          methodCore[event].pub({
+            topic: 'repository::' + repository_ + '.' + method
+          }, output);
+          return output;
+        }
+      };
+    },
+    event: name => methodCore[name],
+    job: name => {
+      return {
+        async cmd(code, data, config) {
+          return await libCore.bull.job(name).cmd(code, data, config);
+        }
+      };
+    },
+    seneca: name => {
+      return {
+        async cmd(name_, data) {
+          return await libCore['seneca']['clients'][name].cmd(name_, data);
+        }
+      };
+    },
+    grpc: name => {
+      return {
+        duplex(name_, fn) {
+          libCore['grpc']['clients'][name](name_).duplex(fn);
+        },
+        data(name_, input, fn, end) {
+          libCore['grpc']['clients'][name](name_).data(input, fn, end);
+        },
+        stream(name_, fn) {
+          return libCore['grpc']['clients'][name](name_).stream(fn);
+        },
+        async cmd(name_, data) {
+          return await libCore['grpc']['clients'][name](name_).cmd(data);
+        }
+      };
+    }
+  };
+  const core = {
+    fileCore: _fileCore.default,
+    async repositories(paths, path, obj) {
+      await _forawait.default.generate(paths, async path_ => {
+        const path_files = _fileCore.default.paths(path + '/' + path_);
+        repositoryCore[path_] = {};
+        await _forawait.default.generate(path_files, async (path_file = '') => {
+          if (!(path_file.includes('.js') || path_file.includes('.ts'))) return;
+          await core.import.repository(path + '/' + path_ + '/' + path_file, {
+            path: path_,
+            file: path_file
+          }, obj);
+        });
+      });
+    },
+    listServices(name) {
+      return Object.keys(services[name]);
+    },
+    forawait: _forawait.default,
+    addLib(lib_, name) {
+      libCore[name] = lib_;
+    },
+    async addMethodCore(driver, file) {
+      methodCore[driver.name] = await (await core.fileCore.importFile(file)).default(driver.config);
+      libCore[driver.name] = methodCore[driver.name];
+    },
+    import: {
+      async service(path_, params, obj = {}, feature = false) {
+        const nameService = feature ? params.file.split('.')[0] : params.path;
+        if (!services[nameService]) {
+          services[nameService] = {};
+        }
+        const {
+          execute,
+          driver
+        } = await _fileCore.default.import(path_, {
+          seneca: app.seneca,
+          //  command: app.command,
+          job: app.job,
+          service: app.service,
+          nats: app.nats,
+          event: app.event,
+          repository: app.repository,
+          entity: app.entity,
+          util: app.util,
+          lib: app.lib,
+          grpc: app.grpc,
+          ...obj
+        });
+        const nameMethod = feature ? params.path : params.file.split('.')[0];
+        services[nameService][nameMethod] = execute;
+        await _forawait.default.generate(Object.entries(driver || {}), async ([name, dr]) => {
+          if (methodCore[name]) {
+            methodCore[name].sub({
+              topic: dr == true ? nameService + "." + nameMethod : dr
+            }, async (...input) => {
+              try {
+                await services[nameService][nameMethod](input[0]);
+              } catch (error) {
+                console.log(error);
+              }
+            });
+          } else {
+            if (name == "bull" || name == "job") {
+              libCore.bull.addJob({
+                name: dr == true ? nameService + "." + nameMethod : dr
+              }, Job.config);
+              libCore.bull.worker({
+                name: dr == true ? nameService + "." + nameMethod : dr,
+                fn: execute,
+                async completed(job_) {
+                  await methodCore[job_.method || 'redis'].pub({
+                    topic: 'worker::completed:' + name
+                  }, {
+                    name: job_.name,
+                    id: job_.id,
+                    input: job_.data,
+                    output: job_.returnvalue
+                  });
+                },
+                async failed(job_, err) {
+                  await methodCore[job_.method || 'redis'].pub({
+                    topic: 'worker::failed:' + name
+                  }, {
+                    name: job_.name,
+                    id: job_.id,
+                    input: job_.data,
+                    err: err.message
+                  });
+                }
+              });
+            }
+          }
+        });
+      },
+      async entity(path_ = '', params, obj, feature = false) {
+        entityCore[params.file.split('.')[0]] = await _fileCore.default.import(path_, {
+          ...obj,
+          seneca: app.seneca,
+          //  command: app.command,
+          job: app.job,
+          service: app.service,
+          nats: app.nats,
+          event: app.event,
+          repository: app.repository,
+          util: app.util,
+          lib: app.lib,
+          grpc: app.grpc
+        });
+      },
+      async event(path_, params, obj) {
+        const {
+          event,
+          execute
+        } = await _fileCore.default.import(path_, {
+          seneca: app.seneca,
+          //  command: app.command,
+          job: app.job,
+          service: app.service,
+          nats: app.nats,
+          event: app.event,
+          repository: app.repository,
+          util: app.util,
+          lib: app.lib,
+          grpc: app.grpc,
+          driver: app.driver,
+          ...obj
+        });
+        const nameService = params.path + "." + params.file.split('.')[0];
+        if (!event.topic) {
+          event.topic = nameService;
+        }
+        if (!methodCore[event.method]) {
+          if (event.method == "ws") {
+            if (event.type == "client") {
+              methodCore["socket:" + event.name].sub(event, execute);
+            } else {
+              ioCore.server.push({
+                event,
+                execute
+              });
+            }
+          }
+          return;
+        }
+        methodCore[event.method].sub(event, execute);
+        return;
+      },
+      async repository(path_, params, obj, feature = false) {
+        if (!repositoryCore[feature ? params.file.split('.')[0] : params.path]) {
+          repositoryCore[feature ? params.file.split('.')[0] : params.path] = {};
+        }
+        repositoryCore[feature ? params.file.split('.')[0] : params.path][feature ? params.path : params.file.split('.')[0]] = (await _fileCore.default.import(path_, {
+          driver: app.driver,
+          lib: app.lib,
+          ...obj
+        })).execute;
+      },
+      async lib(path_, params, obj) {
+        libCore[params.file.split('.')[0]] = await _fileCore.default.import(path_, obj);
+      },
+      async util(path_, params, obj) {
+        utilCore[params.file.split('.')[0]] = await _fileCore.default.import(path_, {
+          ...obj,
+          service: app.service,
+          repository: app.repository,
+          entity: app.entity,
+          util: app.util,
+          lib: app.lib
+        });
+      },
+      async job(path_, params, obj = {}) {
+        const {
+          job: Job,
+          execute
+        } = await _fileCore.default.import(path_, {
+          seneca: app.seneca,
+          //  command: app.command,
+          job: app.job,
+          service: app.service,
+          nats: app.nats,
+          event: app.event,
+          repository: app.repository,
+          util: app.util,
+          lib: app.lib,
+          grpc: app.grpc,
+          ...obj
+        });
+        const name = Job.name || params.path + '.' + params.file.split('.')[0];
+        libCore.bull.addJob({
+          name
+        }, Job.config);
+        libCore.bull.worker({
+          name: Job.name,
+          fn: execute,
+          async completed(job_) {
+            await methodCore[job_.method || 'redis'].pub({
+              topic: 'worker::completed:' + name
+            }, {
+              name: job_.name,
+              id: job_.id,
+              input: job_.data,
+              output: job_.returnvalue
+            });
+          },
+          async failed(job_, err) {
+            await methodCore[job_.method || 'redis'].pub({
+              topic: 'worker::failed:' + name
+            }, {
+              name: job_.name,
+              id: job_.id,
+              input: job_.data,
+              err: err.message
+            });
+          }
+        });
+      },
+      async endPoint(path_, params, obj = {}) {
+        const route = await _fileCore.default.import(path_, {
+          seneca: app.seneca,
+          //  command: app.command,
+          job: app.job,
+          service: app.service,
+          nats: app.nats,
+          event: app.event,
+          repository: app.repository,
+          util: app.util,
+          lib: app.lib,
+          grpc: app.grpc,
+          ...obj
+        });
+        if (Array.isArray(route)) {
+          return route;
+        }
+        return [route];
+      }
+    },
+    app
+  };
+  const createDriver = (0, _driverCore.default)({
+    core
+  });
+  const createServer = (0, _serverCore.default)({
+    core
+  });
+  return {
+    core,
+    createWorker: (0, _workerCore.default)({
+      core
+    }),
+    createRepository: (0, _repositoryCore.default)({
+      core
+    }),
+    createService: (0, _serviceCore.default)({
+      core
+    }),
+    createUtil: (0, _utilCore.default)({
+      core
+    }),
+    createEntity: (0, _entityCore.default)({
+      core
+    }),
+    createLib: (0, _libCore.default)({
+      core
+    }),
+    createEvent: (0, _eventCore.default)({
+      core
+    }),
+    async createServer(server) {
+      if (!createServer[server.type]) return;
+      await createServer[server.type]({
+        server,
+        ws: ioCore
+      });
+    },
+    async createDriver(driver) {
+      if (!createDriver[driver.type]) return;
+      await createDriver[driver.type](driver);
+    }
+  };
+};
+exports.default = _default;

package/cjs/core/libCore.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = ({
+  core
+}) => {
+  return async ({
+    path = '/src/core/libs'
+  }, obj = {}) => {
+    const paths = core.fileCore.paths(path);
+    await core.forawait.generate(paths, async (path_file = '') => {
+      if (!(path_file.includes('.js') || path_file.includes('.ts'))) return;
+      await core.import.lib(path + '/' + path_file, {
+        file: path_file
+      }, obj);
+    });
+  };
+};
+exports.default = _default;

package/cjs/core/repositoryCore.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = ({
+  core
+}) => {
+  return async ({
+    path = '/src/infra/repositories',
+    db = '/src/infra/db/index.js'
+  }, obj = {}) => {
+    const paths = core.fileCore.paths(path);
+    obj.dbTest = process.env.DB_TEST == "True";
+    if (obj.dbTest == true) {
+      if (typeof obj.getDb == 'function') {
+        obj.db = obj.getDb();
+      }
+    } else {
+      try {
+        if (!obj.dbTest && !obj.getDb) {
+          obj.db = await core.fileCore.import(db, {});
+        }
+      } catch (error) {}
+    }
+    await core.repositories(paths, path, obj);
+  };
+};
+exports.default = _default;

package/cjs/core/serverCore.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _nodePath = _interopRequireDefault(require("node:path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = ({
+  core
+}) => {
+  const servicesGet = (services_, server) => {
+    const services = [];
+    services_.forEach((service_ = '') => {
+      const [s, m] = (service_.name || service_).split('.');
+      if (m == '*') {
+        core.listServices(s).forEach(_ => {
+          services.push({
+            name: (server?.name ? server?.name + ":" : '') + s + '.' + _,
+            auth: service_.auth || null,
+            exec: s + '.' + _
+          });
+        });
+        return;
+      }
+      services.push({
+        name: (server?.name ? server?.name + ":" : '') + s + '.' + m,
+        auth: service_.auth || null,
+        exec: s + '.' + m
+      });
+    });
+    return services;
+  };
+  return {
+    async "http"({
+      server,
+      ws
+    }) {
+      const endPoints = [];
+      const rootFile = server.file || server.rootPath || '/src/infra/web/http.js';
+      const rootPath = _nodePath.default.dirname(rootFile);
+      const createCoreRouter = async ({
+        path = rootPath + '/routers'
+      }, obj) => {
+        const paths = core.fileCore.paths(path);
+        await core.forawait.generate(paths, async (path_file = '') => {
+          if (!(path_file.includes('.js') || path_file.includes('.ts'))) return;
+          const route = await core.import.endPoint(path + '/' + path_file, {}, obj);
+          endPoints.push(...route);
+        });
+        return endPoints;
+      };
+      const createCoreSocket = async ({
+        path = rootPath + '/ws'
+      }, obj) => {
+        const paths = core.fileCore.paths(path);
+        const sockets = {};
+        await core.forawait.generate(paths, async (path_file = '') => {
+          if (!(path_file.includes('.js') || path_file.includes('.ts'))) return;
+          sockets[path_file.split('.')[0]] = await core.fileCore.import(path + '/' + path_file, {
+            seneca: core.app.seneca,
+            events: (ws?.server || []).filter(io => {
+              return io.event.route == path_file.split('.')[0];
+            }),
+            service: core.app.service,
+            nats: core.app.nats,
+            grpc: core.app.grpc,
+            job: core.app.job,
+            event: core.app.event,
+            util: core.app.util,
+            lib: core.app.lib,
+            ...obj
+          });
+        });
+        return Object.values(sockets);
+      };
+      const routers = await createCoreRouter({}, {});
+      const wsServer = await createCoreSocket({}, {});
+      try {
+        const serve = await core.fileCore.import(rootFile, {
+          util: app.util,
+          lib: app.lib,
+          routers,
+          ws: wsServer
+        });
+        await serve.start();
+        core.addLib(() => serve.io, 'ws');
+        core.addLib({
+          stop: async () => await serve.stop(),
+          start: async () => await serve.start()
+        }, 'http');
+      } catch (error) {
+        console.error(error.message);
+      }
+    },
+    async "nats"({
+      server
+    }) {
+      const services = servicesGet(server.services, server);
+      await core.forawait.generate(services, async service => {
+        core.app.driver(server.driver).service((server?.prefix || "") + service.name, core.app.service(service.exec).execute, async headers => {
+          if (!service.auth) return true;
+          try {
+            const [m, exec] = service.auth.split(":");
+            const [name, c] = exec.split(".");
+            return (await core.app[m](name)[c](headers)) || false;
+          } catch (error) {
+            return false;
+          }
+        });
+      });
+    },
+    async "fogu"({
+      server
+    }) {
+      const fogu = core.app.driver(server.driver);
+      await core.forawait.generate(server.channels, async channelObj => {
+        const channel = fogu.channel(channelObj.name);
+        const services = servicesGet(channelObj.services || [], server);
+        await core.forawait.generate(services, async service => {
+          await channel.action((server?.prefix || "") + service.name, async (message, reply) => {
+            let input = message;
+            try {
+              input = JSON.parse(input);
+            } catch (error) {}
+            try {
+              let res = await core.app.service(service.exec).execute(input);
+              try {
+                res = JSON.stringify(input);
+              } catch (error) {}
+              const response = Buffer.from(res);
+              reply(null, response);
+            } catch (error) {
+              reply(error.message || 'error', Buffer.from(""));
+            }
+          });
+        });
+      });
+    }
+  };
+};
+exports.default = _default;

package/cjs/core/serviceCore.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = ({
+  core
+}) => {
+  return async ({
+    path = '/src/app/services'
+  }, obj = {}) => {
+    const paths = core.fileCore.paths(path);
+    await core.forawait.generate(paths, async path_ => {
+      const path_files = core.fileCore.paths(path + '/' + path_);
+      await core.forawait.generate(path_files, async (path_file = '') => {
+        if (!(path_file.includes('.js') || path_file.includes('.ts'))) return;
+        await core.import.service(path + '/' + path_ + '/' + path_file, {
+          path: path_,
+          file: path_file
+        }, obj);
+      });
+    });
+  };
+};
+exports.default = _default;