**`create-org-app`** é um *framework modular e orientado a eventos* para construção de aplicações escaláveis, distribuídas e multi-driver.
npm install create-org-appcreate-org-app é um framework modular e orientado a eventos para construção de aplicações escaláveis, distribuídas e multi-driver.
app/services)
app/events)
core/entities)
core/libs)
core/utils)
infra/)
index.js e start.js)
bash
npm install create-org-app
`
---
📁 Estrutura Geral
`
src/
├── app/
│ ├── services/
│ │ └── test/app.js
│ └── events/
│ └── test/app.js
│
├── core/
│ ├── entities/
│ │ └── user.js
│ ├── libs/
│ │ └── password.js
│ └── utils/
│ └── auth.js
│
├── infra/
│ ├── db/
│ │ └── index.js
│ ├── repositories/
│ │ └── test/app.js
│ ├── web/
│ │ ├── http.js
│ │ ├── routers/
│ │ │ └── test.js
│ │ └── ws/
│ │ └── test.js
│ └── workers/
│ └── worker.js
│
├── start.js
└── index.js
`
---
⚙️ Ciclo de Vida da Aplicação
$3
`js
export default {
async bootstrap({ core }) {
core.service("test.app").execute({});
/*
core.driver("nats").command("test.app1", { name: "ssssss" }, {
apiKey: "sssss"
});
*/
},
async distroy(core) {
console.log("close", e);
}
};
`
| Método | Momento | Descrição |
| --------------------- | -------- | -------------------------------------------------------------------------------------- |
| bootstrap({ core }) | Startup | Executado na inicialização. Ideal para pré-carregar serviços, listeners e integrações. |
| distroy(core) | Shutdown | Executado no encerramento da aplicação, para limpar conexões e recursos. |
---
🚀 start.js
`js
import { app } from "../esm/index.js";
// import { app } from "create-org-app";
await app.run({
drivers: [
/ { type: "nats", name: "nats", config: { servers: process.env.NATS_URL } }, /
],
servers: [
{ type: "http", rootPath: "" },
/ { type: "nats", driver: "nats", services: ["test."] } */
]
});
`
---
🧩 Estrutura Avançada — Exemplo Completo
A seguir, um exemplo de integração entre todos os módulos principais, com suporte a eventos, serviços, entidades, DB, Web, WS e Workers.
---
$3
`js
// Evento interno (Node)
export default () => ({
event: {
method: "node"
},
execute: (data) => {
console.log(data, "event");
}
});
`
`js
// Evento WebSocket
export default () => ({
event: {
method: "ws",
route: "/test",
topic: "test.app"
},
execute: (data) => {
console.log(data, "event");
}
});
`
---
$3
`js
export default ({ entity, repository }) => ({
driver: {
node: true
},
async execute(data) {
console.log(data);
const app = await entity("user").entity(data);
const res = await repository("test.app").execute(app.id || "ddddddddddd");
return { data: res };
}
});
`
---
$3
`js
import { z } from "zod";
export default () => ({
entity(data) {
const schema = z.object({
id: z.string().optional(),
name: z.string().min(2)
});
return schema.parse(data);
},
dto() {
return { name: "sss" };
}
});
`
---
$3
`js
export default () => ({
password(text) {
return text;
},
compare(password, hash) {
return password === hash;
}
});
`
---
$3
`js
export default () => ({
apiKey(headers) {
console.log(headers);
return false;
}
});
`
---
$3
`js
export default () => ({
app: {
findUnique(id) {
return id;
}
}
});
`
---
$3
`js
export default ({ db }) => ({
async execute(id) {
return await db.app.findUnique(id);
}
});
`
---
$3
`js
export default ({ util }) => ([
{
url: "/api/test",
method: "get",
middlewares: [util("auth").apiKey([])],
async handler(request, reply) {
const { user } = request;
try {
reply.send({ data: user });
} catch (error) {
reply.status(500).send({ error: error.message });
}
}
}
]);
`
---
$3
`js
import forawait from "../../../../esm/forawait.js";
export default ({ events }) => ({
route: "/test",
async auth(socket, next) {
try {
next();
} catch (error) {
next(error);
}
},
async connection(socket) {
console.info("Socket connected!", socket.id);
socket.join("test");
forawait.generate(events, (io) => {
socket.on(io.event.topic, (input, cb) => {
io.execute({ input, cb }, { socket, io: this });
});
});
socket.on("disconnect", async () => {
console.log("disconnect:" + socket.id);
});
}
});
`
---
$3
`js
export default ({ routers = [], ws = [] }) => ({
io: null,
async start() {
console.log(routers, ws);
},
async stop() {}
});
`
---
$3
`js
export default ({ service }) => ({
job: {
name: "test.app",
method: "node"
},
async execute({ data }) {
await service("test.app").execute(data);
return {};
}
});
`
---
🧪 Testes Automatizados (
vitest)
`js
import { expect, describe, beforeAll, afterEach, test } from "vitest";
import { testApp } from "../esm/index.js";
let core = {};
beforeAll(async () => {
const { core: Core } = await testApp.run({
db: {
app: {
async findUnique(id) {
return { id, name: "dddd", desc: "ddddddd" };
}
}
}
});
core = Core;
Core.event("node").sub({ topic: "service::test.app" }, ({ data }) => {
console.log(data);
Core.event("node").pub({ topic: "test.app" }, { id: data.id });
});
});
describe("core", () => {
test("executa serviço principal", async () => {
const res = await core.service("test.app").execute({ name: "ddd" }, "node");
expect(res.data).toBeDefined();
expect(res.error).toBeUndefined();
expect(res.data.id).toBeDefined();
});
});
`
---
🧩 Configuração Avançada — Multi-Drivers e Servidores
`js
await app.run({
drivers: [
{
type: "nats",
name: "nats",
config: { servers: "nats://localhost:4222" }
},
{
type: "redis",
name: "redis",
config: { url: "redis://localhost:6379" }
},
{
type: "bull",
name: "bull",
config: { url: "redis://localhost:6379" }
}
],
servers: [
{
type: "http",
rootPath: "/api"
},
{
type: "ws",
route: "/ws",
driver: "nats"
},
{
type: "nats",
driver: "nats",
services: [
"test.app",
{ name: "test.app1", auth: "util:auth.apiKey" }
]
}
]
});
`
---
🧠 Fluxo de Inicialização
`
start.js
↓
app.run(config)
↓
index.js → bootstrap({ core })
↓
core.service("test.app").execute({})
↓
Serviço → Entidade → Repositório → DB
↓
Eventos → Workers → Web → WS
`
---
✅ Conclusão
A integração de create-org-app com index.js e start.js` fornece: