@anteros/core 0.0.23 → 0.0.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anteros/core",
   "module": "index.ts",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "type": "module",
   "description": "Anteros Core",
   "private": false,
@@ -10,7 +10,8 @@
     "bun": ">=1.3.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.14"
+    "@types/bun": "^1.3.14",
+    "@types/tcp-port-used": "^1.0.4"
   },
   "peerDependencies": {
     "typescript": "6.0.3"
@@ -29,6 +30,7 @@
     "jose": "6.2.8",
     "mongodb": "7.5.0",
     "socket.io": "4.8.3",
+    "tcp-port-used": "^1.0.3",
     "ufo": "1.6.4",
     "zod": "^4.4.3"
   }

package/server/boot.ts

@@ -22,18 +22,7 @@ import crypto from 'node:crypto';
 import os from 'node:os';
 import { registerMetrics, getMetrics, trackRequest } from './metrics';
 import { startMaster, aggregateMetrics } from './cluster';
-
-/** Check if a TCP port is already bound */
-async function isPortInUse(port: number): Promise<boolean> {
-    try {
-        const proc = Bun.spawn(['lsof', '-ti', `:${port}`], { stdout: 'pipe' });
-        const output = await new Response(proc.stdout).text();
-        await proc.exited;
-        return output.trim().length > 0;
-    } catch {
-        return false;
-    }
-}
+import tcpPortUsed from 'tcp-port-used';
 
 type BootAppOptions = ServerConfig & {
 
@@ -117,14 +106,38 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
 
             console.log(`[cluster] Aggregated /health → http://localhost:${metricsPort}/health`.gray);
 
+            // Graceful shutdown: stop workers + metrics server so a restart
+            // (e.g. bun --watch) never leaves the port occupied
+            const shutdownCluster = (signal: string) => {
+                console.log(`\n${signal} received — shutting down workers…`.gray);
+                try { master.shutdown(); } catch {}
+                try { metricsServer.stop(true); } catch {}
+                for (const tenant of cfg.tenants ?? []) {
+                    try { tenant.database?.client?.close(); } catch {}
+                }
+                process.exit(0);
+            };
+            process.once('SIGINT', () => shutdownCluster('SIGINT'));
+            process.once('SIGTERM', () => shutdownCluster('SIGTERM'));
+
             // Keep the master alive
             return { master, metricsServer } as any;
         }
 
-        // Detect zombie: check if port is already in use when NOT sharing the port
+        // Detect zombie: check if port is already in use when NOT sharing the port.
+        // tcp-port-used probes with a real TCP connection — only a listening server
+        // counts (a connected client never triggers a false positive) and it works
+        // on any platform (no lsof dependency). Grace period: after a restart the
+        // previous process may still be releasing the port (Mongo / Socket.IO
+        // shutdown) — wait before declaring a zombie.
         if (!reusePort && env === 'dev') {
-            const occupied = await isPortInUse(PORT);
-            if (occupied) {
+            if (await tcpPortUsed.check(PORT)) {
+                console.log(`⏳ Port ${PORT} is still held, waiting for the previous process to release it (~2.5s)…`.gray);
+            }
+            try {
+                // ~2.5s grace (5 × 500ms); rejects if the port stays occupied
+                await tcpPortUsed.waitUntilFree(PORT, 500, 2500);
+            } catch {
                 console.error(`\n⚠ Port ${PORT} is already in use. Possible zombie server.\n  → Kill it: lsof -ti :${PORT} | xargs kill -9\n`.red.bold);
                 process.exit(1);
             }
@@ -158,6 +171,19 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
         // Register server for built-in metrics (GET /health)
         registerMetrics(server);
 
+        // Graceful shutdown: release the port & DB connections so restarts
+        // (e.g. bun --watch) never hit a zombie / EADDRINUSE
+        const shutdownServer = (signal: string) => {
+            console.log(`\n${signal} received — shutting down…`.gray);
+            try { server.stop(true); } catch {}
+            for (const tenant of cfg.tenants ?? []) {
+                try { tenant.database?.client?.close(); } catch {}
+            }
+            process.exit(0);
+        };
+        process.once('SIGINT', () => shutdownServer('SIGINT'));
+        process.once('SIGTERM', () => shutdownServer('SIGTERM'));
+
         // ── WORKER (cluster): report metrics to the master via IPC ──
         if (isWorker && typeof process.send === 'function') {
             setInterval(() => {

package/tests/api.test.ts

@@ -73,6 +73,56 @@ describe("find", () => {
     });
 });
 
+describe("$limit", () => {
+    it("$limit: 0 means no limit (returns all matching docs)", async () => {
+        const marker = `limit-zero-${crypto.randomUUID()}`;
+        await rest.bulkWrite("items", Array.from({ length: 101 }, (_, i) => ({
+            insertOne: { document: { title: marker, count: i } },
+        })) as any);
+
+        const all = await rest.find("items", { $match: { title: marker }, $limit: 0 });
+        expect(all.length).toBe(101); // the old 100 cap would have returned 100
+
+        await rest.db.collection("items").deleteMany({ title: marker });
+    });
+
+    it("accepts $limit above 1000", async () => {
+        const marker = `limit-big-${crypto.randomUUID()}`;
+        await rest.insertMany("items", [
+            { title: marker, count: 1 },
+            { title: marker, count: 2 },
+            { title: marker, count: 3 },
+        ]);
+
+        const docs = await rest.find("items", { $match: { title: marker }, $limit: 5000 });
+        expect(docs.length).toBe(3);
+
+        await rest.db.collection("items").deleteMany({ title: marker });
+    });
+
+    it("defaults to $limit 100", async () => {
+        const marker = `limit-default-${crypto.randomUUID()}`;
+        await rest.bulkWrite("items", Array.from({ length: 120 }, (_, i) => ({
+            insertOne: { document: { title: marker, count: i } },
+        })) as any);
+
+        const docs = await rest.find("items", { $match: { title: marker } });
+        expect(docs.length).toBe(100);
+
+        await rest.db.collection("items").deleteMany({ title: marker });
+    });
+
+    it("rejects negative $limit with INVALID_LIMIT", async () => {
+        const err: any = await rest.find("items", { $limit: -1 }).then(() => null, (e) => e);
+        expect(err?.code).toBe("INVALID_LIMIT");
+    });
+
+    it("rejects non-integer $limit with INVALID_LIMIT", async () => {
+        const err: any = await rest.find("items", { $limit: 1.5 }).then(() => null, (e) => e);
+        expect(err?.code).toBe("INVALID_LIMIT");
+    });
+});
+
 describe("findOne", () => {
     it("returns single doc by _id", async () => {
         const doc = await rest.insertOne("items", { title: "single" });

package/utils/func.ts

@@ -748,18 +748,20 @@ function buildPipeline(p: FindOptions, options?: {
         })
     }
 
-    // $limit — Faille 14: must be a safe integer in (0, MAX_LIMIT]; 0 would mean "no limit"
-    const MAX_LIMIT = 1000;
+    // $limit — 0 means "no limit" (the $limit stage is omitted);
+    // any positive safe integer is allowed (no 1000 cap)
     p.$limit = p?.$limit ?? 100
-    if (!Number.isSafeInteger(p.$limit) || p.$limit <= 0 || p.$limit > MAX_LIMIT) {
-        throw new AppError(`Invalid $limit (expected an integer between 1 and ${MAX_LIMIT})`, {
+    if (!Number.isSafeInteger(p.$limit) || p.$limit < 0) {
+        throw new AppError(`Invalid $limit (expected a non-negative integer; 0 = no limit)`, {
             code: 'INVALID_LIMIT',
             status: 400
         });
     }
-    pipeline.push({
-        $limit: p.$limit
-    })
+    if (p.$limit > 0) {
+        pipeline.push({
+            $limit: p.$limit
+        })
+    }
 
     // $include
     if (p?.$include && Array.isArray(p?.$include)) {