@anteros/core 0.0.1-alpha.1

package/lib/scripts.ts

@@ -0,0 +1,47 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import type { Script } from "../types/scripts"
+import { useRest } from "../database/rest"
+import { asyncContextStorage, requestCtxStorage } from "./asyncContextStorage"
+
+
+async function runScripts() {
+    let scripts: (Script & { rest: InstanceType<typeof useRest> })[] = []
+    for (let tenant of cfg.tenants ?? []) {
+        const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+        const SCRIPTS_PATH = path.join(TENANT_PATH, 'scripts')
+        let exist = await fs.exists(SCRIPTS_PATH)
+        if (!exist) continue;
+        const isDirectory = await (await fs.stat(SCRIPTS_PATH)).isDirectory()
+        if (isDirectory) {
+            const glob = new Glob(path.join(SCRIPTS_PATH, '**/*.run.ts'))
+            for await (let file of glob.scan('.')) {
+                let scriptModule = await import(file)
+                if (scriptModule?.default?._isScript_ && scriptModule?.default?.enabled) {
+                    scripts.push({
+                        ...scriptModule?.default,
+                        rest: new useRest({
+                            tenant_id: tenant.id,
+                        })
+                    })
+                }
+            }
+        }
+    }
+
+    for (let script of scripts) {
+        asyncContextStorage.run(new Map(), async () => {
+            requestCtxStorage.set('trace', { id: crypto.randomUUID() })
+            requestCtxStorage.set('internal', true)
+
+            await script.exec({
+                rest: script.rest
+            })
+        })
+    }
+}
+export {
+    runScripts
+}

package/lib/services.ts

@@ -0,0 +1,45 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import { useRest } from "../database/rest"
+
+
+async function loadServices() {
+    try {
+        let services = []
+        for (let tenant of cfg.tenants ?? []) {
+            const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+            const SERVICES_PATH = path.join(TENANT_PATH, 'services')
+            let exist = await fs.exists(SERVICES_PATH)
+            if (!exist) continue;
+            const isDirectory = await (await fs.stat(SERVICES_PATH)).isDirectory()
+            if (isDirectory) {
+                const glob = new Glob(path.join(SERVICES_PATH, '**/*.service.ts'))
+                for await (let file of glob.scan('.')) {
+                    let serviceModule = await import(file)
+                    if (serviceModule?.default?._isService_) {
+                        services.push({
+                            ...serviceModule?.default,
+                            _tenant_: tenant.id,
+                            rest: new useRest({
+                                tenant_id: tenant.id,
+                            })
+                        })
+                    }
+                }
+            }
+        }
+
+        cfg.services = services
+
+    } catch (err: any) {
+        console.error(err?.message)
+    }
+
+
+}
+
+export {
+    loadServices
+}

package/lib/sockets.ts

@@ -0,0 +1,44 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import { useRest } from "../database/rest"
+import { io } from "../server/io"
+import type { WebSocketHandler } from "../types/websocket"
+
+
+async function loadSockets() {
+    try {
+        for (let tenant of cfg.tenants ?? []) {
+            const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+            const SOCKETS_PATH = path.join(TENANT_PATH, 'sockets')
+            const exist = await fs.exists(SOCKETS_PATH)
+            if (!exist) continue
+            const isDirectory = await (await fs.stat(SOCKETS_PATH)).isDirectory()
+            if (!isDirectory) continue
+
+            const glob = new Glob(path.join(SOCKETS_PATH, '**/*.ws.ts'))
+            for await (let file of glob.scan('.')) {
+                const socketModule = await import(file)
+                const handler = socketModule?.default as WebSocketHandler | undefined
+
+                if (handler?._isWebSocket_ && handler.enabled) {
+                    const rest = new useRest({ tenant_id: tenant.id })
+
+                    io.on('connection', (socket) => {
+                        handler.exec({ io, rest, socket })
+                    })
+
+                    console.log(`[socket] ${tenant.id}/${path.basename(file, '.ws.ts')} loaded`)
+                }
+            }
+        }
+
+    } catch (err: any) {
+        console.error('[socket] Failed to load sockets:', err?.message)
+    }
+}
+
+export {
+    loadSockets
+}

package/lib/workflow.ts

@@ -0,0 +1,60 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import type { WorkflowDefinition } from "../types/workflow"
+import { getTenant } from "../database/tenant"
+
+const workflows: Map<string, WorkflowDefinition> = new Map();
+
+async function syncWorkflows() {
+    try {
+        workflows.clear();
+        for (let tenant of cfg.tenants ?? []) {
+            const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+            const WORKFLOWS_PATH = path.join(TENANT_PATH, 'workflows')
+            let exist = await fs.exists(WORKFLOWS_PATH)
+            if (!exist) continue;
+            const isDirectory = await (await fs.stat(WORKFLOWS_PATH)).isDirectory()
+            if (!isDirectory) continue;
+
+            const glob = new Glob(path.join(WORKFLOWS_PATH, '**/*.workflow.ts'))
+            for await (let file of glob.scan('.')) {
+                let module = await import(file)
+                if (module?.default?._isWorkflow_) {
+                    const wf: WorkflowDefinition = { ...module.default, _tenant_: tenant.id }
+                    workflows.set(`${tenant.id}:${wf.id}`, wf)
+                }
+            }
+        }
+
+        // Créer les indexes sur _workflows_ pour les contextes définis
+        for (const [key, wf] of workflows) {
+          const tenantId = key.split(':')[0]
+          if (!wf.context || !tenantId) continue
+          const tenant = getTenant(tenantId)
+          const db = tenant?.database?.db
+          if (!db) continue
+
+          for (const [field, config] of Object.entries(wf.context)) {
+            const direction = config.index === true || config.index === 1 ? 1 : config.index === -1 ? -1 : 0
+            if (direction === 0) continue
+
+            try {
+              const indexKey = `context.${field}`
+              await db.collection('_workflows_').createIndex({ [indexKey]: direction })
+            } catch (err: any) {
+              console.error(`Failed to create index on _workflows_.${field}:`, err?.message)
+            }
+          }
+        }
+    } catch (err: any) {
+        console.error('Failed to sync workflows:', err?.message)
+    }
+}
+
+function getWorkflow(id: string, tenantId: string): WorkflowDefinition | undefined {
+    return workflows.get(`${tenantId}:${id}`)
+}
+
+export { syncWorkflows, getWorkflow }

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@anteros/core",
+  "module": "index.ts",
+  "version": "0.0.1-alpha.1",
+  "type": "module",
+  "description": "Anteros Core",
+  "private": false,
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14"
+  },
+  "peerDependencies": {
+    "typescript": "6.0.3"
+  },
+  "dependencies": {
+    "@colors/colors": "^1.6.0",
+    "@socket.io/bun-engine": "^0.1.1",
+    "bentocache": "^1.6.1",
+    "boxen": "^8.0.1",
+    "dayjs": "^1.11.21",
+    "hono": "^4.12.25",
+    "ioredis": "^5.11.1",
+    "joi": "^18.2.1",
+    "jose": "^6.2.3",
+    "mongodb": "7.2.0",
+    "socket.io": "^4.8.3",
+    "ufo": "^1.6.4"
+  }
+}