org-core-js 0.0.1

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

package/cjs/core/workerCore.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = ({
+  core
+}) => {
+  return async ({
+    path = '/src/infra/workers'
+  }, obj) => {
+    const paths = core.fileCore.paths(path);
+    if (!paths.length) return;
+    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.job(path + '/' + path_ + '/' + path_file, {
+          path: path_,
+          file: path_file
+        }, obj);
+      });
+    });
+  };
+};
+exports.default = _default;

package/cjs/fileCore.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+var _default = exports.default = {
+  path: process.cwd(),
+  async import(file, obj = {}) {
+    return (await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))('file://' + _path.default.resolve(this.path + file))).default(obj);
+  },
+  async importFile(file) {
+    return await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))('file://' + _path.default.resolve(this.path + file));
+  },
+  exist(path_file) {
+    return _fs.default.existsSync(_path.default.resolve(this.path + path_file));
+  },
+  paths(paths) {
+    if (!this.exist(paths)) return [];
+    return _fs.default.readdirSync(_path.default.resolve(this.path + paths));
+  },
+  bin: _fs.default.existsSync(process.cwd() + '/esm') ? '/esm' : '/node_modules/create-org-app/esm'
+};

package/cjs/forawait.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  generator: function* generator(array) {
+    for (let index = 0; index < array.length; index++) {
+      yield array[index];
+    }
+  },
+  generator_fn: function* generator(data) {
+    if (Array.isArray(data)) {
+      for (let index = 0; index < data.length; index++) {
+        yield {
+          data: data[index],
+          index
+        };
+      }
+    } else {
+      data = Object.entries(data);
+      for (let index = 0; index < data.length; index++) {
+        yield {
+          data: data[index][1],
+          name: data[index][0]
+        };
+      }
+    }
+  },
+  generate: async function (data, fn, ops = {}, fun_error = console.log) {
+    let flag = false;
+    const fn_g = this.generator_fn(data);
+    while (!flag) {
+      const {
+        value,
+        done
+      } = fn_g.next();
+      if (value) {
+        try {
+          await fn(value.data, {
+            ...ops,
+            index: value.index,
+            name: value.name
+          });
+        } catch (error) {
+          try {
+            await fun_error(error);
+          } catch (error) {}
+        }
+      }
+      flag = done;
+    }
+  }
+};

package/cjs/index.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testApp = exports.app = void 0;
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _fileCore = _interopRequireDefault(require("./fileCore.js"));
+var _index = _interopRequireDefault(require("./core/index.js"));
+var _forawait = _interopRequireDefault(require("./forawait.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config();
+const app = exports.app = {
+  async run({
+    servers,
+    drivers,
+    bootFile = "/src/index.js"
+  }) {
+    const initBoot = await _fileCore.default.importFile(bootFile);
+    const {
+      bootstrap,
+      distroy
+    } = initBoot.default || initBoot;
+    const sys = (0, _index.default)({});
+    await sys.createLib({}, {});
+    await sys.createUtil({}, {});
+    await sys.createEntity({}, {});
+    await sys.createRepository({}, {});
+    await sys.createService({}, {});
+    await _forawait.default.generate(drivers, async driver => {
+      await sys.createDriver(driver);
+    });
+    await sys.createEvent({}, {});
+    await sys.createWorker({}, {});
+    await _forawait.default.generate(servers, async server => {
+      await sys.createServer(server);
+    });
+    process.on('uncaughtException', (error, origin) => {
+      console.log(`\n${origin} signal received. \n${error}`);
+    });
+    process.on('SIGINT', grafulShutdown('SIGINT'));
+    process.on('SIGTERM', grafulShutdown('SIGTERM'));
+    process.on('exit', async code => {
+      try {
+        await distroy({
+          sys: {
+            ...sys.core.import
+          },
+          core: {
+            ...sys.core.app
+          }
+        });
+      } catch (error) {}
+      console.log('exit signal received', code);
+    });
+    function grafulShutdown(event) {
+      return async code => {
+        console.log(`${event} received! with ${code}`);
+        try {
+          await distroy({
+            sys: {
+              ...sys.core.import
+            },
+            core: {
+              ...sys.core.app
+            }
+          });
+        } catch (error) {}
+        process.exit(0);
+      };
+    }
+    await bootstrap({
+      sys: {
+        ...sys.core.import
+      },
+      core: {
+        ...sys.core.app
+      }
+    });
+  }
+};
+const testApp = exports.testApp = {
+  async run({
+    db = {},
+    setDB = null
+  } = {}) {
+    const sys = (0, _index.default)({});
+    await sys.createLib({}, {});
+    await sys.createUtil({}, {});
+    await sys.createEntity({}, {});
+    await sys.createEvent({}, {});
+    await sys.createService({}, {});
+    process.env.DB_TEST = "True";
+    await sys.createRepository({}, {
+      db: db,
+      getDB: setDB
+    });
+    process.on('uncaughtException', (error, origin) => {
+      console.log(`\n${origin} signal received. \n${error}`);
+    });
+    process.on('SIGINT', grafulShutdown('SIGINT'));
+    process.on('SIGTERM', grafulShutdown('SIGTERM'));
+    process.on('exit', async code => {
+      console.log('exit signal received', code);
+    });
+    function grafulShutdown(event) {
+      return async code => {
+        console.log(`${event} received! with ${code}`);
+      };
+    }
+    return {
+      core: {
+        ...sys.core.app
+      }
+    };
+  }
+};

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/esm/core/driverCore.js

@@ -0,0 +1,33 @@
+
+export default ({ core }) => {
+    return {
+        async "nats"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/nats.js'
+            await core.addMethodCore(driver, file)
+        },
+        async "redis"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/redis.js'
+            await core.addMethodCore(driver, file)
+        },
+        async "bull"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/bull.js'
+            await core.addMethodCore(driver, file)
+        },
+    
+        async "socket"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/socket.js'
+            await core.addMethodCore(driver, file)
+        },
+        async "rabbitmq"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/rabbitmq.js'
+            await core.addMethodCore(driver, file)
+        },
+        async "fogu"(driver) {
+            const file = core.fileCore.bin + '/core/drivers/fogu.js'
+            await core.addMethodCore(driver, file)
+        }
+
+    }
+
+
+}

package/esm/core/drivers/bull.js

@@ -0,0 +1,49 @@
+
+import { Queue, Worker } from 'bullmq'
+let url
+const jobs = {}
+export default async ({ connection = {
+    host: process.env.REDIS_HOST,
+    port: process.env.REDIS_PORT,
+    password: process.env.REDIS_PASSWORD
+} }) => {
+    return {
+        async close() {
+
+        },
+        async connect({ url: url3 }) {
+            url = url3
+        },
+        job(name_job) {
+            return {
+                async cmd(name, data, config) {
+                    await jobs[name_job].add(name, data);
+                }
+            }
+        },
+        addJob: ({ name }) => {
+            jobs[name] = new Queue(name, {
+                connection
+            });
+
+        },
+        worker: ({
+            name,
+            fn,
+            completed = job => {
+                console.log(`${job.id} has completed!`);
+            },
+            failed = (job, err) => {
+                console.log(`${job.id} has failed with ${err.message}`);
+            }
+
+        }) => {
+            const myWorker = new Worker(name, fn, {
+                connection
+            });
+            myWorker.on('completed', completed);
+            myWorker.on('failed', failed);
+
+        }
+    }
+}

package/esm/core/drivers/fogu.js

@@ -0,0 +1,12 @@
+import { Fogu } from 'fmp-js';
+
+
+
+export default async (config) => {
+// Or create a new instance explicitly:
+    const client = new Fogu();
+    await client.connect(config.url)
+    return client
+
+}
+

package/esm/core/drivers/nats.js

@@ -0,0 +1,160 @@
+import { connect, StringCodec, headers, Empty } from "nats";
+export default async (config) => {
+    let nc = await connect(config);
+    const sc = 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 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 = 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
+
+        }
+    }
+}

package/esm/core/drivers/rabbitmq.js

@@ -0,0 +1,64 @@
+import amqplib from 'amqplib';
+let client
+export default async (config) => {
+    client = await amqplib.connect(config.url || 'amqp://localhost');
+    client = await client.createChannel();
+    return {
+        async connect() {
+            client = await amqplib.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
+                }
+            )
+        },
+    }
+
+}

package/esm/core/drivers/redis.js

@@ -0,0 +1,71 @@
+import { createClient } from 'redis';
+export default async (config) => {
+    let clientPub = null
+    let clientSub = null
+    clientPub = 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 = 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)
+            });
+        }
+
+    }
+}
+
+

package/esm/core/drivers/socket.js

@@ -0,0 +1,28 @@
+
+import { io } from "socket.io-client";
+export default ({ }) => ({
+    client: null,
+    async close() {
+
+    },
+    async connect({ url, config = {} }) {
+        this.client = 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);
+    }
+
+})
+
+

package/esm/core/entityCore.js

@@ -0,0 +1,12 @@
+
+export 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)
+        })
+    }
+}