@anteros/core 0.0.31 → 0.0.33

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/package.json

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

package/server/boot.ts

@@ -245,6 +245,21 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
         box += `${NAME}`.gray.underline + ` (PID: ${process.pid}) — ${role}\n\n`
         box += `Env: ${env || 'dev'}`.green.bold + '\n'
         box += `reusePort: ${(reusePort || isWorker) ? 'On'.green.bold : 'Off'.red.bold}\n`.gray.bold
+
+        // DB query cache status (server.cache) — driver: memory | filesystem | redis
+        const cacheCfg = cfg.server.cache;
+        // any: @colors/colors type les styles chaînés (.red.bold) comme des fonctions Color
+        let cacheInfo: any = 'Off'.red.bold;
+        if (cacheCfg?.enabled) {
+            const driver = cacheCfg.driver ?? 'memory';
+            const detail = driver === 'filesystem'
+                ? ` ${cacheCfg.directory ?? './.cache'}`
+                : driver === 'redis'
+                    ? ` ${cacheCfg.redis?.host ?? 'localhost'}${cacheCfg.redis?.port ? `:${cacheCfg.redis.port}` : ''}`
+                    : '';
+            cacheInfo = `On`.green.bold + ` (${driver}${detail})`;
+        }
+        box += `Cache: ${cacheInfo}`.gray.bold + '\n'
         box += `Url: http://localhost:${PORT}`.gray.bold;
         box += '\n\n';
         box += `Last boot: 🔄 ${dayjs().format('YYYY-MM-DD HH:mm:ss')}`.gray;

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/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;