org-core-js 0.0.1

package/cjs/core/drivers/nats.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _nats = require("nats");
+var _default = async config => {
+  let nc = await (0, _nats.connect)(config);
+  const sc = (0, _nats.StringCodec)();
+  const js = nc.jetstream();
+  const stores = {};
+
+  // create an entry - this is similar to a put, but will fail if the
+  // key exists
+
+  return {
+    store: {
+      kv(kv) {
+        return {
+          async create(name, data) {
+            let input = data;
+            if (typeof input == 'object') {
+              input = JSON.stringify(input);
+            }
+            const e = await stores[kv].get(name);
+            let value = new TextDecoder().decode(e?.value);
+            if (e && value) return;
+            await stores[kv].create(name, sc.encode(input));
+          },
+          async del(name) {
+            await stores[kv].delete(name);
+          },
+          async set(name, data) {
+            let input = data;
+            if (typeof input == 'object') {
+              input = JSON.stringify(input);
+            }
+            await stores[kv].put(name, sc.encode(input));
+          },
+          async get(name) {
+            const e = await stores[kv].get(name);
+            let value = new TextDecoder().decode(e?.value);
+            try {
+              value = JSON.parse(value);
+            } catch (error) {
+              value = new TextDecoder().decode(e?.value);
+            }
+            return value;
+          }
+        };
+      },
+      async createKV(name, fn, config = {
+        history: 5
+      }) {
+        stores[name] = await js.views.kv(name, config);
+        const watch = await stores[name].watch();
+        (async () => {
+          for await (const e of watch) {
+            if (!fn) return;
+            await fn(e);
+          }
+        })().then();
+      }
+    },
+    async close() {
+      return nc.drain();
+    },
+    sub({
+      topic
+    }, fn, config = {}) {
+      //{ queue: queue || '' }
+      (async sub => {
+        for await (const m of sub) {
+          let input = new TextDecoder().decode(m.data);
+          try {
+            input = JSON.parse(input);
+          } catch (error) {
+            input = new TextDecoder().decode(m.data);
+          }
+          try {
+            await fn(input);
+          } catch (error) {}
+        }
+      })(nc.subscribe(topic, config));
+    },
+    pub({
+      topic
+    }, data) {
+      let input = data;
+      if (typeof input == 'object') {
+        input = JSON.stringify(input);
+      }
+      nc.publish(topic, sc.encode(Buffer.from(input)));
+    },
+    async connect() {
+      nc = await (0, _nats.connect)({
+        servers
+      });
+    },
+    service(name, fn, auth = null, config = {}) {
+      (async sub => {
+        for await (const m of sub) {
+          const headers = m.headers;
+          if (auth) {
+            try {
+              const ok = await auth({
+                get(name) {
+                  return headers?.get(name);
+                }
+              });
+              if (!ok) {
+                return m.respond(sc.encode(Buffer.from(JSON.stringify({
+                  error: "dd",
+                  data: null
+                }))));
+              }
+            } catch (error) {
+              return m.respond(sc.encode(Buffer.from(JSON.stringify({
+                error: "dd",
+                data: null
+              }))));
+            }
+          }
+          let input = new TextDecoder().decode(m.data);
+          try {
+            input = JSON.parse(input);
+          } catch (error) {
+            input = new TextDecoder().decode(m.data);
+          }
+          const res = await fn(input);
+          if (m.respond(sc.encode(Buffer.from(JSON.stringify(res || {}))))) {
+            //  console.info(`[time] handled #${sub.getProcessed()}`);
+          } else {
+            //  console.log(`[time] #${sub.getProcessed()} ignored - no reply subject`);
+          }
+        }
+      })(nc.subscribe("service:" + name, config));
+    },
+    async command(name, data = {}, _headers = {}, config = {}) {
+      const h = (0, _nats.headers)();
+      Object.entries(_headers).forEach(([key, value]) => {
+        h.append(key, value);
+      });
+      let input = data;
+      if (typeof input == 'object') {
+        input = JSON.stringify(input);
+      }
+      const res = await nc.request("service:" + name, sc.encode(Buffer.from(input)), {
+        timeout: config.timeout || 5000,
+        headers: h
+      });
+      let output = new TextDecoder().decode(res.data);
+      try {
+        output = JSON.parse(output);
+      } catch (error) {}
+      return output;
+    }
+  };
+};
+exports.default = _default;

package/cjs/core/drivers/osone.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _osone = require("osone");
+var _default = async config => {
+  // Ou criar uma nova instância
+  const osone = (0, _osone.New)();
+  await osone.connect(config.url);
+  return osone;
+};
+exports.default = _default;

package/cjs/core/drivers/rabbitmq.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _amqplib = _interopRequireDefault(require("amqplib"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let client;
+var _default = async config => {
+  client = await _amqplib.default.connect(config.url || 'amqp://localhost');
+  client = await client.createChannel();
+  return {
+    async connect() {
+      client = await _amqplib.default.connect(config.url || 'amqp://localhost');
+      client = await client.createChannel();
+    },
+    async close() {},
+    async send(queue, data) {
+      let input = data;
+      await client.assertQueue(queue);
+      if (typeof data == 'object') {
+        input = JSON.stringify(input);
+      }
+      return client.sendToQueue(queue, Buffer.from(input));
+    },
+    async sub({
+      queue,
+      topic,
+      pattern = '',
+      exchangeType = 'topic'
+    }, fn = console.log) {
+      await client.assertQueue(queue);
+      if (topic && exchangeType) {
+        await client.assertExchange(topic, exchangeType);
+        await client.bindQueue(queue, topic, pattern);
+      }
+      client.consume(queue, async msg => {
+        if (msg !== null) {
+          let input = msg.content.toString();
+          try {
+            input = JSON.parse(input);
+          } catch (error) {}
+          await fn({
+            data: input,
+            ack: () => client.ack(msg)
+          });
+          //ch1.ack(msg);
+        }
+      });
+    },
+    async pub({
+      routingKey = '',
+      topic = 'my-topic',
+      exchangeType = 'topic'
+    }, data) {
+      await client.assertExchange(topic, exchangeType);
+      let input = data;
+      if (typeof data == 'object') {
+        input = JSON.stringify(input);
+      }
+      return client.publish(topic, routingKey, Buffer.from(input), {
+        persistent: true
+      });
+    }
+  };
+};
+exports.default = _default;

package/cjs/core/drivers/redis.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _redis = require("redis");
+var _default = async config => {
+  let clientPub = null;
+  let clientSub = null;
+  clientPub = (0, _redis.createClient)(config);
+  clientPub.on('error', err => console.log('Redis Client Error', err));
+  clientSub = clientPub.duplicate();
+  await clientPub.connect();
+  await clientSub.connect();
+  return {
+    client: clientPub,
+    async connect() {
+      clientPub = (0, _redis.createClient)(config);
+      clientPub.on('error', err => console.log('Redis Client Error', err));
+      clientSub = clientPub.duplicate();
+      await clientPub.connect();
+      await clientSub.connect();
+      this.client = clientPub;
+    },
+    async close() {
+      await client.disconnect();
+      await clientSub.disconnect();
+      await clientPub.disconnect();
+    },
+    async set(key, value) {
+      let input = value;
+      try {
+        input = JSON.stringify(input);
+      } catch (error) {}
+      await clientPub.set(key, input);
+    },
+    async get(key) {
+      const res = await clientPub.get(key);
+      let data = res;
+      try {
+        data = JSON.parse(res);
+      } catch (error) {}
+      return data;
+    },
+    async pub({
+      topic
+    }, data) {
+      let input = data;
+      try {
+        input = JSON.stringify(input);
+      } catch (error) {}
+      await clientPub.publish(topic, input);
+    },
+    async sub({
+      topic
+    }, cb = console.log) {
+      clientSub.subscribe(topic, async input => {
+        let data = input;
+        try {
+          data = JSON.parse(input);
+        } catch (error) {}
+        await cb(data);
+      });
+    }
+  };
+};
+exports.default = _default;

package/cjs/core/drivers/socket.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _socket = require("socket.io-client");
+var _default = ({}) => ({
+  client: null,
+  async close() {},
+  async connect({
+    url,
+    config = {}
+  }) {
+    this.client = (0, _socket.io)(url, config);
+  },
+  async req(event, input) {
+    return new Promise((resolve, reject) => {
+      this.client.emit(event, input, (error, res) => {
+        if (error) reject(error);
+        resolve(res);
+      });
+    });
+  },
+  async pub({
+    topic
+  }, data) {
+    await this.client.emit(topic, input);
+  },
+  async sub({
+    topic
+  }, cb = console.log) {
+    this.client.on(topic, cb);
+  }
+});
+exports.default = _default;

package/cjs/core/entityCore.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/entities'
+  }, 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.entity(path + '/' + path_file, {
+        file: path_file
+      }, obj);
+    });
+  };
+};
+exports.default = _default;

package/cjs/core/eventCore.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/events'
+  }, 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.event(path + '/' + path_ + '/' + path_file, {
+          path: path_,
+          file: path_file
+        }, obj);
+      });
+    });
+  };
+};
+exports.default = _default;