org-core-js 0.0.1

package/esm/core/eventCore.js

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

package/esm/core/index.js

@@ -0,0 +1,440 @@
+
+import createCoreService from './serviceCore.js'
+import createCoreWorker from './workerCore.js'
+import createCoreRepository from './repositoryCore.js'
+import createCoreServer from './serverCore.js'
+import createCoreDriver from './driverCore.js'
+import createCoreEntity from './entityCore.js';
+import createCoreUtil from './utilCore.js';
+import createCoreLib from './libCore.js';
+import createCoreEvent from './eventCore.js';
+import forawait from '../forawait.js'
+import fileCore from '../fileCore.js'
+import { EventEmitter } from 'node:events';
+import crypto from 'node:crypto'
+
+
+const eventCore = new EventEmitter()
+const libCore = {
+    forawait,
+    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) => {
+                crypto.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);
+        }
+    }
+}
+
+export 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,
+        async repositories(paths, path, obj) {
+            await forawait.generate(paths, async (path_,) => {
+                const path_files = fileCore.paths(path + '/' + path_)
+                repositoryCore[path_] = {}
+                await forawait.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,
+        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.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.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.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.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.import(path_, {
+                    driver: app.driver,
+                    lib: app.lib,
+                    ...obj
+                })).execute
+            },
+            async lib(path_, params, obj) {
+                libCore[params.file.split('.')[0]] = (await fileCore.import(path_, obj))
+            },
+            async util(path_, params, obj) {
+                utilCore[params.file.split('.')[0]] = (await fileCore.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.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.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 = createCoreDriver({ core })
+    const createServer = createCoreServer({ core })
+    return {
+        core,
+        createWorker: createCoreWorker({ core }),
+        createRepository: createCoreRepository({ core }),
+        createService: createCoreService({ core }),
+        createUtil: createCoreUtil({ core }),
+        createEntity: createCoreEntity({ core }),
+        createLib: createCoreLib({ core }),
+        createEvent: createCoreEvent({ 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)
+        }
+    }
+}

package/esm/core/libCore.js

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

package/esm/core/repositoryCore.js

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

package/esm/core/serverCore.js

@@ -0,0 +1,155 @@
+import path from "node:path"
+export 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 = path.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(""))
+                    }
+
+                })
+            })
+            
+            })
+ 
+       
+
+        }
+
+    }
+
+
+}

package/esm/core/serviceCore.js

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

package/esm/core/utilCore.js

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