@anteros/core 0.0.30 → 0.0.32

package/database/collection.ts

@@ -8,6 +8,22 @@ import type { Field } from "../types/field"
 import { getTenant } from "./tenant"
 import { buildSchema } from "./schema"
 import type { FileCollection } from "../types/file"
+
+/**
+ * Mongo index options must be real booleans: `unique`/`sparse`/… accept
+ * `1`/`0`/`true`/`false` but NEVER `null`/`undefined` (otherwise the server
+ * throws `The field 'sparse' has value null, which is not convertible to bool`).
+ * Coerce truthiness (`1` → `true`, `0` → `false`) and drop nullish values entirely.
+ */
+const BOOLEAN_INDEX_OPTIONS = ['unique', 'sparse', 'background', 'hidden'];
+function applyIndexOptions(spec: IndexDescription, options?: Field['indexOptions']): IndexDescription {
+    for (const [k, v] of Object.entries(options ?? {})) {
+        if (v === undefined || v === null) continue; // never send null/undefined on the wire
+        (spec as unknown as Record<string, unknown>)[k] = BOOLEAN_INDEX_OPTIONS.includes(k) ? !!v : v;
+    }
+    return spec;
+}
+
 async function syncCollections() {
     try {
 
@@ -115,17 +131,17 @@ async function initializeOnDatabase(collections: Collection[]) {
                             }
                         }
 
-                        let isSparse = field.type === 'random'
-                            || (field.unique && field.required !== true);
+                        // !! : field.unique peut être 1/0 (Mongo-style) → coercer en vrai booléen
+                        let isSparse = !!(field.type === 'random'
+                            || (field.unique && field.required !== true));
 
-                        specsFieldsIndexes.push({
+                        specsFieldsIndexes.push(applyIndexOptions({
                             key: {
                                 [field.name]: indexValue as any
                             },
-                            unique: field.unique ?? false,
+                            unique: !!field.unique, // 1/0/true/false → real boolean
                             sparse: isSparse,
-                            ...field.indexOptions,  // explicit overrides win
-                        })
+                        }, field.indexOptions)) // explicit overrides win — sanitized
 
                     }
 

package/database/decorator.ts

@@ -22,7 +22,7 @@ export function LogSlowQuery(): any {
                 const duration = performance.now() - start;
                 const slowMs = cfg.server.logging?.slowQueryMs ?? 200;
                 if (duration >= slowMs) {
-                    logger.warn(`Slow ${propertyKey} (${Math.round(duration)}ms)`, {
+                    logger.file('warn', `Slow ${propertyKey} (${Math.round(duration)}ms)`, {
                         collection: args[0],
                         tenant: this.tenant_id,
                         duration: Math.round(duration),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anteros/core",
   "module": "index.ts",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "description": "Anteros Core",
   "private": false,

package/server/boot.ts

@@ -177,7 +177,8 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
                         const remote: any = (server as any).requestIP?.(req);
                         const remoteIp = remote?.address ?? null;
                         const remotePort = remote?.port ?? null;
-                        logger.info(`${req.method} ${url.pathname}${url.search} → ${res.status}`, {
+                        // File-only: same as the API access log, no console noise.
+                        logger.file(`${req.method} ${url.pathname}${url.search} → ${res.status}`, {
                             logger: 'http.log.access',
                             status: res.status,
                             duration: Math.round((performance.now() - start) * 10) / 10,

package/server/hono.ts

@@ -234,7 +234,8 @@ function createApp(): Hono<{ Variables: HonoVariables }> {
             const remoteIp = conn?.remote?.address ?? null;
             const remotePort = conn?.remote?.port ?? null;
 
-            logger.info(`${c.req.method} ${uri} → ${c.res.status}`, {
+            // File-only: the per-request access log would flood the console.
+            logger.file(`${c.req.method} ${uri} → ${c.res.status}`, {
                 logger: 'http.log.access',
                 status: c.res.status,
                 duration: Math.round(duration * 10) / 10,

package/server/mcp.ts

@@ -124,7 +124,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
             description: t.description,
             inputSchema: joiToJsonSchema(t.inputSchema),
         }));
-        logger.info('MCP tools/list', { method: 'tools/list', tenant: tenantId, count: toolsList.length, duration: ms(start) });
+        logger.file('MCP tools/list', { method: 'tools/list', tenant: tenantId, count: toolsList.length, duration: ms(start) });
         return { tools: toolsList };
     });
 
@@ -132,14 +132,14 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
         const start = performance.now();
         const tool = tools.find((t) => t.name === req.params.name);
         if (!tool) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, error: 'unknown tool', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, error: 'unknown tool', duration: ms(start) });
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${req.params.name}`);
         }
 
         const raw = req.params.arguments ?? {};
         const { error, value } = tool.inputSchema.validate(raw, { allowUnknown: false });
         if (error) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: raw, error: 'invalid arguments', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: raw, error: 'invalid arguments', duration: ms(start) });
             return {
                 content: [{ type: 'text' as const, text: `Invalid arguments: ${error.message}` }],
                 isError: true,
@@ -155,7 +155,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
             const text = typeof result === 'string' ? result : JSON.stringify(result);
             return { content: [{ type: 'text' as const, text }] };
         } catch (err: any) {
-            logger.warn('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: value, error: err?.message ?? 'unknown', duration: ms(start) });
+            logger.file('warn', 'MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: value, error: err?.message ?? 'unknown', duration: ms(start) });
             return {
                 content: [{ type: 'text' as const, text: `Error: ${err?.message ?? 'unknown'}` }],
                 isError: true,
@@ -173,7 +173,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 description: r.description,
                 mimeType: r.mimeType,
             }));
-        logger.info('MCP resources/list', { method: 'resources/list', tenant: tenantId, count: resourcesList.length, duration: ms(start) });
+        logger.file('MCP resources/list', { method: 'resources/list', tenant: tenantId, count: resourcesList.length, duration: ms(start) });
         return { resources: resourcesList };
     });
 
@@ -187,7 +187,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 description: r.description,
                 mimeType: r.mimeType,
             }));
-        logger.info('MCP resources/templates/list', { method: 'resources/templates/list', tenant: tenantId, count: templates.length, duration: ms(start) });
+        logger.file('MCP resources/templates/list', { method: 'resources/templates/list', tenant: tenantId, count: templates.length, duration: ms(start) });
         return { resourceTemplates: templates };
     });
 
@@ -196,7 +196,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
         const uri = req.params.uri;
         const matched = matchUri(uri, resources);
         if (!matched) {
-            logger.warn('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: 'unknown uri', duration: ms(start) });
+            logger.file('warn', 'MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: 'unknown uri', duration: ms(start) });
             throw new McpError(ErrorCode.InvalidParams, `Unknown resource URI: ${uri}`);
         }
 
@@ -208,10 +208,10 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
                 params: matched.params,
                 uri,
             });
-            logger.info('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, resource: matched.resource.name, params: matched.params, duration: ms(start) });
+            logger.file('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, resource: matched.resource.name, params: matched.params, duration: ms(start) });
             return result;
         } catch (err: any) {
-            logger.warn('MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: err?.message ?? 'unknown', duration: ms(start) });
+            logger.file('warn', 'MCP resources/read', { method: 'resources/read', tenant: tenantId, uri, error: err?.message ?? 'unknown', duration: ms(start) });
             throw new McpError(ErrorCode.InternalError, `Failed to read resource: ${err?.message ?? 'unknown'}`);
         }
     });

package/tests/fixtures/index-tenant/collections/variants.model.ts

@@ -0,0 +1,14 @@
+import { define } from "../../../../index";
+
+// Reproduces the Mongo error `sparse: null is not convertible to bool`:
+// `indexOptions.sparse` explicit à null doit être ignoré (jamais envoyé à Mongo),
+// et `unique` accepte le style Mongo 1/0 (coercé en vrai booléen).
+export default define.Collection({
+    slug: "variants",
+    fields: [
+        { name: "name", type: "string", index: true, indexOptions: { sparse: null as any } },
+        { name: "sku", type: "string", unique: 1 },
+        { name: "price", type: "number" },
+    ],
+    api: { access: { "*": true } },
+});

package/tests/index-spec.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { formatConfig, cfg } from "../server/config";
+import { syncTenants } from "../database/tenant";
+import { syncCollections } from "../database/collection";
+
+const TENANT = "idx-test";
+const DIR = "packages/core/tests/fixtures/index-tenant";
+const DB = "mongodb://localhost:27017/_DB_IDX_TEST";
+
+// initializeOnDatabase est fire-and-forget dans syncCollections — on attend
+// que les index existent réellement en base.
+async function waitForIndexes(colName: string): Promise<any[]> {
+    const db = cfg.tenants?.[0]?.database?.db as any;
+    const col = db.collection(colName);
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        try {
+            const idxs = await col.listIndexes().toArray();
+            if (idxs.length) return idxs;
+        } catch {}
+        await Bun.sleep(50);
+    }
+    throw new Error(`indexes not created for ${colName}`);
+}
+
+beforeAll(async () => {
+    formatConfig({
+        server: { port: 4000 },
+        tenants: [{ id: TENANT, dir: DIR, database: { uri: DB } }],
+    });
+    await syncTenants();
+    await syncCollections();
+});
+
+afterAll(async () => {
+    try { await (cfg.tenants?.[0]?.database?.db as any)?.collection("variants").drop(); } catch {}
+});
+
+describe("index spec construction", () => {
+    it("drops null/undefined options and coerces Mongo-style 1/0 booleans", async () => {
+        const idxs = await waitForIndexes("variants");
+
+        // name : indexOptions.sparse = null → ignoré (pas de sparse:null), index créé
+        const nameIdx = idxs.find((i) => i.name === "name_1");
+        expect(nameIdx).toBeDefined();
+        expect(nameIdx!.sparse).not.toBe(null);
+        expect(nameIdx!.sparse).not.toBe(true); // false / undefined — jamais null
+
+        // sku : unique: 1 (Mongo-style) → index unique réel
+        const skuIdx = idxs.find((i) => i.name === "sku_1");
+        expect(skuIdx).toBeDefined();
+        expect(skuIdx!.unique).toBe(true);
+    });
+});

package/tests/logger.test.ts

@@ -121,4 +121,27 @@ describe("logger", () => {
         expect(out.some((l) => l.includes("visible info"))).toBe(true);
         expect(out.some((l) => l.includes("Server started"))).toBe(false);
     });
+
+    it("logger.file keeps the level when passed explicitly (never on console)", async () => {
+        const out: string[] = [];
+        const orig = console.log;
+        console.log = (...a: any[]) => { out.push(a.join(" ")); };
+
+        logger.configure({ dir: path.join(DIR, "filelevel"), file: true, console: true, level: "info" });
+        logger.file("default level", { a: 1 }); // 2-arg form → level 'info'
+        logger.file("warn", "explicit warn", { b: 2 }); // explicit level kept
+        logger.file("error", "explicit error", { c: 3 });
+        await flush();
+        console.log = orig;
+
+        const lines = readLogLines("filelevel/anteros.log");
+        expect(lines.find((l) => l.msg === "default level")!.level).toBe("info");
+        expect(lines.find((l) => l.msg === "explicit warn")!.level).toBe("warn");
+        expect(lines.find((l) => l.msg === "explicit warn")!.b).toBe(2);
+        expect(lines.find((l) => l.msg === "explicit error")!.level).toBe("error");
+        // never on the console, whatever the level
+        expect(out.some((l) => l.includes("default level"))).toBe(false);
+        expect(out.some((l) => l.includes("explicit warn"))).toBe(false);
+        expect(out.some((l) => l.includes("explicit error"))).toBe(false);
+    });
 });

package/types/field.d.ts

@@ -52,7 +52,7 @@ export type Field = {
     required?: boolean;
     enumOptions?: enumOptions;
     slugOptions?: SlugOptions;
-    unique?: boolean;
+    unique?: boolean | 1 | 0; // Mongo-style: true/1 → unique index, false/0 → non-unique
     nullable?: boolean;
     empty?: boolean;
     defaultValue?: number | string | boolean | object | array<any>;
@@ -63,9 +63,9 @@ export type Field = {
     | "2d"
     indexOptions?: {
         expireAfterSeconds?: number;
-        sparse?: boolean;
+        sparse?: boolean | 1 | 0;
         version?: number;
-        unique?: boolean;
+        unique?: boolean | 1 | 0;
     };
     relation?: {
         to: string;

package/utils/logger.ts

@@ -186,8 +186,20 @@ class Logger {
     warn(msg: string, meta?: unknown) { this.#write('warn', msg, meta); }
     error(msg: string, meta?: unknown) { this.#write('error', msg, meta); }
 
-    /** Write to the file only (no console output) — for events that would clutter the terminal */
-    file(msg: string, meta?: unknown) { this.#write('info', msg, meta, { console: false }); }
+    /**
+     * Write to the file only (no console output) — for framework-internal events
+     * (access log, MCP operations, slow queries) that would clutter the terminal.
+     * Level defaults to 'info'; `file('warn', msg, meta)` keeps the level.
+     */
+    file(msg: string, meta?: unknown): void;
+    file(level: LogLevel, msg: string, meta?: unknown): void;
+    file(levelOrMsg: LogLevel | string, msgOrMeta?: unknown, meta?: unknown): void {
+        if (levelOrMsg === 'debug' || levelOrMsg === 'info' || levelOrMsg === 'warn' || levelOrMsg === 'error') {
+            this.#write(levelOrMsg, msgOrMeta as string, meta, { console: false });
+        } else {
+            this.#write('info', levelOrMsg, msgOrMeta, { console: false });
+        }
+    }
 
     /** Current log file path (empty when file logging is disabled) */
     get filePath(): string { return this.#filePath; }