@anteros/core 0.0.1-alpha.1

package/README.md

@@ -0,0 +1,143 @@
+# @dnax/core
+
+Server core for **multi-tenant** apps: generic **MongoDB** REST API, **Joi** validation, hooks, JWT auth, custom routes, and boot scripts. Built for **Bun** with **Hono** and **Socket.io**.
+
+## Requirements
+
+- [Bun](https://bun.sh) (recommended runtime for this package)
+- A reachable MongoDB instance (per-tenant URI)
+- TypeScript (peer dependency)
+
+## Installation
+
+```bash
+bun add @dnax/core@0.0.0-rc.13
+```
+
+## Quick start
+
+Typical entrypoint in your app (working directory = project root that contains tenant folders):
+
+```ts
+import { app, define } from "@dnax/core";
+
+await app.boot({
+  clusterMode: false,
+  server: {
+    port: 5000,
+    jwt: {
+      secret: process.env.JWT_SECRET, // or JWT_SECRET env var
+      expiresIn: "1h",
+    },
+    cors: {
+      origin: ["http://localhost:3000"],
+      credentials: true,
+    },
+  },
+  tenants: [
+    {
+      id: "v1",
+      dir: "v1", // relative path to tenant code (collections, routes, scripts)
+      routes: { prefix: "/api/v1" }, // required for loading declared routes
+      database: {
+        uri: "mongodb://localhost:27017/my_database",
+      },
+    },
+  ],
+});
+```
+
+On boot, the server syncs tenants, loads collections (`*.model.ts`), registers routes (`*.route.ts`), starts HTTP/WebSocket, then runs enabled scripts (`*.run.ts`).
+
+## Public exports
+
+| Export | Purpose |
+|--------|---------|
+| `define` | Factories: `define.Collection`, `define.Route`, `define.Script`, `define.Server` / `define.App` |
+| `app` | `{ boot }` — starts the application |
+| `useRest` | REST client / per-tenant Mongo access (programmatic use or in handlers) |
+| `v` | **Joi** (re-export), for schemas in models |
+| `utils` | Internal utilities exposed by the package |
+
+## Folder layout (per tenant)
+
+**`dir` is required** on every tenant: it is the path (relative to the project root) under which the folders below are resolved.
+
+Paths are relative to `tenant.dir` (e.g. `v1/` when `id` and `dir` are `v1`):
+
+| Path | Contents |
+|------|----------|
+| `collections/**/*.model.ts` | Collection models (`define.Collection({ ... })`) |
+| `routes/**/*.route.ts` | Custom HTTP routes (`define.Route({ ... })`), requires `tenant.routes.prefix` |
+| `scripts/**/*.run.ts` | Startup scripts (`define.Script({ ... })`) |
+
+## Generic HTTP API
+
+A single route handles collection operations:
+
+```http
+POST /api/:tenant_id/:collection/:action
+Content-Type: application/json
+```
+
+Example `action` values: `find`, `findOne`, `insertOne`, `insertMany`, `updateOne`, `updateMany`, `deleteOne`, `deleteMany`, `findOneAndUpdate`, `aggregate`, `login`, `logout`, plus **named actions** declared on the model.
+
+Typical JSON bodies: `{ "data": ... }`, `{ "params": ... }`, `{ "pipeline": ... }`, `{ "payload": ... }` (login), depending on the action.
+
+The tenant must exist in config; the collection must be registered via a `*.model.ts` file.
+
+### JWT and `Authorization` header
+
+If the client sends `Authorization: Bearer <jwt>`, the core **verifies** it before your route handler runs. Invalid or expired tokens return **401** immediately.
+
+When verification succeeds, the Hono context exposes:
+
+| Field | Meaning |
+|-------|--------|
+| `token.value` | Raw JWT string (same as in the header) |
+| `token.decoded` | Verified payload (claims), e.g. `sub`, `role` |
+
+If there is **no** `Authorization` header, `token` is not set on the context. Collection **`api.access`** functions receive:
+
+```ts
+token: {
+  value: string | null;       // raw JWT, or null if no Bearer was sent
+  decoded: Record<string, unknown> | null; // verified claims, or null if unauthenticated
+};
+```
+
+Use **`token.decoded`** for roles, `sub`, etc. Use **`token.value`** if you need the string (e.g. forwarding). Implement rules in `api.access` for each action you want to protect.
+
+### Access control (`api.access`)
+
+Per collection, `api.access` allows or denies each action (`boolean` or async function). Wildcard `'*'` applies when no specific rule exists for an action.
+
+### Auth (`api.auth`)
+
+When `api.auth.enabled` is set, define `onLogin` / `onLogout` on the model. The JWT secret is read from `server.jwt.secret` or the **`JWT_SECRET`** environment variable.
+
+## Server configuration
+
+Common options when calling `app.boot`:
+
+- `clusterMode` — Bun `reusePort` for multiple workers
+- `server.port`, `server.name`
+- `server.cors` — origins, credentials, headers, and methods
+- `server.ipRestriction` — allow/deny lists (Hono)
+- `server.jwt` — secret and token lifetime
+
+## Socket.io
+
+The server mounts **Socket.io** at `/socket.io/`. Route handlers receive the `io` instance for real-time subscriptions.
+
+## Environment variables
+
+| Variable | Usage |
+|----------|--------|
+| `JWT_SECRET` | JWT signing when not set in config |
+| `NODE_ENV` / `Bun.env.NODE_ENV` | Environment label at boot |
+| `APP_NAME` | Server name when `server.name` is omitted |
+
+## License
+
+See the parent repository for the project license.

package/database/collection.ts

@@ -0,0 +1,160 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import type { Collection } from "../types/collection"
+import type { IndexDescription } from "mongodb"
+import type { Field } from "../types/field"
+import { getTenant } from "./tenant"
+import { buildSchema } from "./schema"
+import type { FileCollection } from "../types/file"
+async function syncCollections() {
+    try {
+
+        const collections: Collection[] = []
+        for (let tenant of cfg.tenants ?? []) {
+            const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+            const COLLECTIONS_PATH = path.join(TENANT_PATH, 'collections')
+            let exist = await fs.exists(COLLECTIONS_PATH)
+            if (!exist) continue;
+            const isDirectory = await (await fs.stat(COLLECTIONS_PATH)).isDirectory()
+
+            if (isDirectory) {
+                const glob = new Glob(path.join(COLLECTIONS_PATH, '**/*.model.ts'))
+                for await (let file of glob.scan('.')) {
+                    let collectionModule = await import(file)
+                    if (collectionModule?.default?._isCollection_) {
+                        collections.push({
+                            ...collectionModule?.default,
+                            _tenant_: tenant.id
+                        })
+                    }
+                }
+            }
+        }
+
+        // construction des schema arktype pour les collections
+        for (let collection of collections) {
+            collection._schema_ = buildSchema(collection)
+            collection._schemaPartial_ = buildSchema(collection, { partial: true })
+        }
+
+        initializeOnDatabase(collections).catch(err => {
+            console.error('Initialize collections on database failed', err?.message)
+        })
+        cfg.collections = collections
+
+    } catch (err: any) {
+        console.error(err?.message)
+    }
+}
+
+
+
+
+async function initializeOnDatabase(collections: Collection[]) {
+    for (let collection of collections) {
+        try {
+            const tenant = getTenant(collection._tenant_!)
+            const db = tenant?.database?.db
+            if (db && collection) {
+
+                // create collection on database
+                if (!collection?._isTimeSerie_) {
+                    await db.createCollection(collection.slug)
+                }
+
+                // create default index on collection
+                let specsTimeStamps = {
+                    createdAt: -1,
+                    updatedAt: -1
+                }
+                await db.collection(collection.slug).createIndex(specsTimeStamps)
+                // console.log('index created on collection', collection.slug, index)
+
+
+
+                // creation d'index sur les champs
+                let specsFieldsIndexes: IndexDescription[] = []
+                for (let field of collection?.fields || []) {
+                    field.indexOptions = field.indexOptions ?? {}
+                    if ((field.type == 'random' && Object.keys(field.randomOptions ?? {}).length) || field.unique) {
+                        field.index = field.index ?? true
+                        field.indexOptions.unique = true
+                    }
+
+                    if (field?.index) {
+                        let indexValue: Boolean | number = field.index;
+                        let includesStringType: Field['type'][] = ['string', 'email', 'enum', 'url', 'random'];
+                        let includesDateType: Field['type'][] = ['date', 'datetime-local'];
+                        if (typeof indexValue == "boolean" && includesStringType.includes(field.type)) {
+                            indexValue = 1
+                        }
+
+                        if (typeof indexValue == "boolean" && includesDateType.includes(field.type)) {
+                            indexValue = -1
+                        }
+                        specsFieldsIndexes.push({
+                            key: {
+                                [field.name]: indexValue as number
+                            },
+                            unique: field.unique ?? false,
+                            sparse: field.type == 'random' ? true : false,
+                            ...field.indexOptions,
+                        })
+
+                    }
+
+
+
+                }
+                if (specsFieldsIndexes.length) {
+                    await db.collection(collection.slug).createIndexes(specsFieldsIndexes)
+                }
+            }
+
+        } catch (err: any) {
+            console.error(err?.message)
+
+        }
+    }
+}
+
+function getCollection(collectionName: string, tenantId: string): Collection | null {
+
+    let col = cfg.collections?.find(collection => collection.slug == collectionName && collection._tenant_ == tenantId)
+
+    if (col) {
+        return col
+    }
+
+    // Chercher aussi dans les file collections
+    let fileCol = cfg.fileCollections?.find(fc => fc.slug == collectionName && fc._tenant_ == tenantId)
+    if (fileCol) {
+        return {
+            slug: fileCol.slug,
+            type: 'file',
+            fields: fileCol.fields ?? [],
+            api: fileCol.api as any,
+            hooks: fileCol.hooks as any,
+            _tenant_: fileCol._tenant_,
+            _schema_: fileCol._schema_,
+            _schemaPartial_: fileCol._schemaPartial_,
+        }
+    }
+
+    return null
+}
+
+
+function getCollectionKeys(collection: Collection): string[] {
+    return collection.fields.map(field => field.name)
+}
+
+
+
+export {
+    syncCollections,
+    getCollection,
+    getCollectionKeys
+}

package/database/decorator.ts

@@ -0,0 +1,172 @@
+import { ObjectId } from "mongodb";
+import { getCollection } from "./collection";
+import { AppError } from "../lib/error";
+
+
+// decoration function checkCollectionExists
+export function CheckIfCollectionExists(): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            let collection = args[0];
+            let col = getCollection(collection, this.tenant_id)
+            if (!col) {
+                throw new AppError(`collection '${collection}' not found`, {
+                    code: 'COLLECTION_NOT_FOUND',
+                    status: 500
+                })
+            }
+            return await originalMethod.apply(this, args);
+        };
+        return descriptor;
+    }
+}
+
+
+
+export function CheckIfArrayOfIds(action: string): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+
+            let _ids = args[1];
+            if (!Array.isArray(_ids)) {
+                throw new AppError(`[${action}] IDs must be an array`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+            }
+            for (let id of _ids) {
+                if (!ObjectId.isValid(id)) {
+                    throw new AppError(`[${action}] IDs must be an array of valid ObjectId`, {
+                        code: 'INVALID_ARGUMENT',
+                        status: 400
+                    })
+                }
+            }
+            if (_ids.length === 0) {
+                throw new AppError(`[${action}] IDs must be an array of at least one valid ObjectId`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+            }
+            return await originalMethod.apply(this, args);
+        }
+        return descriptor;
+    };
+}
+
+export function CheckInsertData(action: string): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            let data = args[1];
+            if (action === 'insertOne') {
+                if (!data) throw new AppError(`[${action}] Data is required`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+            }
+            if (action === 'insertMany') {
+                if (!data) throw new AppError(`[${action}] Data is required`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+            }
+            return await originalMethod.apply(this, args);
+        }
+    }
+}
+
+export function CheckIfId(action: string): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            let _id = args[1];
+            if (!ObjectId.isValid(_id)) {
+                throw new AppError(`[${action}] ID must be a valid ObjectId`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+            }
+            return await originalMethod.apply(this, args);
+        }
+        return descriptor;
+    }
+}
+
+
+export function CheckFilter(): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            let filter = args[1];
+            if (
+                filter === null ||
+                filter === undefined ||
+                (typeof filter === 'object' && Object.keys(filter).length === 0)
+            ) {
+                throw new AppError(`[${propertyKey}] Filter is required and must not be empty`, {
+                    code: 'FILTER_REQUIRED',
+                    status: 400
+                })
+            }
+            return await originalMethod.apply(this, args);
+        }
+        return descriptor;
+    }
+}
+
+export function CheckBulkWriteOperations(): any {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor): any {
+        if (!descriptor || !descriptor.value) {
+            return descriptor;
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            let operations = args[1];
+            for (let operation of operations) {
+                if (!operation) throw new AppError(`[bulkWrite] Operation is required`, {
+                    code: 'INVALID_ARGUMENT',
+                    status: 400
+                })
+                if (Object.hasOwn(operation, 'insertOne')) {
+                    if (!operation.insertOne.document) throw new AppError(`[bulkWrite] Document is required`, {
+                        code: 'INVALID_ARGUMENT',
+                        status: 400
+                    })
+                }
+                if (Object.hasOwn(operation, 'updateOne')) {
+                    if (!operation.updateOne.filter) throw new AppError(`[bulkWrite] Filter is required`, {
+                        code: 'INVALID_ARGUMENT',
+                        status: 400
+                    })
+                }
+                if (Object.hasOwn(operation, 'updateOne')) {
+                    if (!operation.updateOne.filter) throw new AppError(`[bulkWrite] Filter is required`, {
+                        code: 'INVALID_ARGUMENT',
+                        status: 400
+                    })
+                }
+            }
+            return await originalMethod.apply(this, args);
+        }
+        return descriptor;
+    }
+}
+

package/database/file.ts

@@ -0,0 +1,93 @@
+import { Glob } from "bun"
+import { cfg } from "../server/config"
+import path from "path"
+import fs from "fs/promises"
+import type { FileCollection } from "../types/file"
+import { getTenant } from "./tenant"
+
+async function syncFileCollections() {
+    try {
+        const fileCollections: FileCollection[] = []
+        for (let tenant of cfg.tenants ?? []) {
+            const TENANT_PATH = path.join(process.cwd(), tenant.dir)
+            const FILES_PATH = path.join(TENANT_PATH, 'files')
+            let exist = await fs.exists(FILES_PATH)
+            if (!exist) continue;
+            const isDirectory = await (await fs.stat(FILES_PATH)).isDirectory()
+
+            if (isDirectory) {
+                // Charger les fichiers *.file.ts
+                const globFiles = new Glob(path.join(FILES_PATH, '**/*.file.ts'))
+                for await (let file of globFiles.scan('.')) {
+                    let fileModule = await import(file)
+                    if (fileModule?.default?._isFileCollection_) {
+                        fileCollections.push({
+                            ...fileModule?.default,
+                            _tenant_: tenant.id
+                        })
+                    }
+                }
+
+                // Charger aussi les fichiers *.model.ts avec _isFileCollection_
+                const globModels = new Glob(path.join(FILES_PATH, '**/*.model.ts'))
+                for await (let file of globModels.scan('.')) {
+                    let fileModule = await import(file)
+                    if (fileModule?.default?._isFileCollection_) {
+                        fileCollections.push({
+                            ...fileModule?.default,
+                            _tenant_: tenant.id
+                        })
+                    }
+                }
+            }
+        }
+
+        cfg.fileCollections = fileCollections
+
+        initializeFileCollectionsOnDatabase(fileCollections).catch(err => {
+            console.error('Initialize file collections on database failed', err?.message)
+        })
+
+    } catch (err: any) {
+        console.error(err?.message)
+    }
+}
+
+async function initializeFileCollectionsOnDatabase(files: FileCollection[]) {
+    for (const fileCollection of files) {
+        try {
+            const tenant = getTenant(fileCollection._tenant_!)
+            const db = tenant?.database?.db
+            if (!db) continue;
+
+            // Créer la collection si elle n'existe pas
+            const collections = await db.listCollections({ name: fileCollection.slug }).toArray()
+            if (collections.length === 0) {
+                await db.createCollection(fileCollection.slug)
+            }
+
+            // Créer les indexes par défaut
+            await db.collection(fileCollection.slug).createIndexes([
+                { key: { filename: 1 } },
+                { key: { name: 1 } },
+                { key: { mimetype: 1 } },
+                { key: { createdAt: -1, updatedAt: -1 } },
+            ])
+
+        } catch (err: any) {
+            console.error(`Initialize file collection '${fileCollection.slug}' failed`, err?.message)
+        }
+    }
+}
+
+function getFileCollection(collectionName: string, tenantId: string): FileCollection | null {
+    let col = cfg.fileCollections?.find(c => c.slug == collectionName && c._tenant_ == tenantId)
+    if (col) return col
+    return null
+}
+
+export {
+    syncFileCollections,
+    getFileCollection,
+    initializeFileCollectionsOnDatabase
+}