@anteros/core 0.0.18 → 0.0.19

package/database/collection.ts

@@ -84,23 +84,35 @@ async function initializeOnDatabase(collections: Collection[]) {
                     }
 
                     if (field?.index) {
-                        let indexValue: Boolean | number = field.index;
-                        let includesStringType: Field['type'][] = ['string', 'email', 'enum', 'url', 'random', 'slug'];
-                        let includesDateType: Field['type'][] = ['date', 'datetime-local'];
-                        if (typeof indexValue == "boolean" && includesStringType.includes(field.type)) {
-                            indexValue = 1
+                        let indexValue: number | string = 1;
+
+                        // Honor explicit indexType first
+                        if (field.indexType) {
+                            indexValue = field.indexType;
+                        } else if (typeof field.index === 'number') {
+                            indexValue = field.index;
+                        } else if (field.type === 'geojson.Point' || field.type === 'geojson.LineString' || field.type === 'geojson.Polygon') {
+                            indexValue = '2dsphere';
+                        } else {
+                            let includesStringType: Field['type'][] = ['string', 'email', 'enum', 'url', 'random', 'slug', 'relationship', 'uuid', 'password'];
+                            let includesDateType: Field['type'][] = ['date', 'datetime-local'];
+                            if (includesStringType.includes(field.type)) {
+                                indexValue = 1;
+                            } else if (includesDateType.includes(field.type)) {
+                                indexValue = -1;
+                            }
                         }
 
-                        if (typeof indexValue == "boolean" && includesDateType.includes(field.type)) {
-                            indexValue = -1
-                        }
+                        let isSparse = field.type === 'random'
+                            || (field.unique && field.required !== true);
+
                         specsFieldsIndexes.push({
                             key: {
-                                [field.name]: indexValue as number
+                                [field.name]: indexValue as any
                             },
                             unique: field.unique ?? false,
-                            sparse: field.type == 'random' ? true : false,
-                            ...field.indexOptions,
+                            sparse: isSparse,
+                            ...field.indexOptions,  // explicit overrides win
                         })
 
                     }
@@ -111,6 +123,22 @@ async function initializeOnDatabase(collections: Collection[]) {
                 if (specsFieldsIndexes.length) {
                     await db.collection(collection.slug).createIndexes(specsFieldsIndexes)
                 }
+
+                // Purge orphan indexes (fields removed from schema)
+                if (collection.purgeOrphanIndexes) {
+                    const expectedKeys = new Set(specsFieldsIndexes.map((idx) =>
+                        JSON.stringify(Object.keys(idx.key!).sort())
+                    ));
+                    const existingIndexes = await db.collection(collection.slug).listIndexes().toArray();
+                    for (const idx of existingIndexes) {
+                        if (idx.name === '_id_') continue; // built-in
+                        const idxKeys = JSON.stringify(Object.keys(idx.key!).sort());
+                        if (!expectedKeys.has(idxKeys)) {
+                            await db.collection(collection.slug).dropIndex(idx.name!);
+                            console.log(`🧹 Dropped orphan index: ${collection.slug}.${idx.name}`.gray);
+                        }
+                    }
+                }
             }
 
         } catch (err: any) {

package/database/mongodbadapter.ts

@@ -72,76 +72,61 @@ class MongoRest {
         })
 
 
-        //let unauthorizedKeys = func.unauthorizedKeys(options.data, getCollectionKeys(col))
-        /*  if (unauthorizedKeys.length > 0) {
-             throw new AppError(`Unauthorized keys in "${options.collection}" : ${unauthorizedKeys.join(', ')}`, {
-                 code: 'UNAUTHORIZED_KEYS',
-                 status: 400
-             })
-         } */
-
-
-
         if (schema && partialSchema) {
 
 
             if (options?.data) {
                 if (options.action == 'insertMany') {
-                    options.data.map(d => {
-                        validationResult = schema.validate(d, {
-                            allowUnknown: false,
-                        })
-                        if (validationResult && validationResult.error) {
+                    for (let i = 0; i < options.data.length; i++) {
+                        validationResult = schema.validate(options.data[i], { allowUnknown: false })
+                        if (validationResult?.error) {
                             throw new AppError(validationResult.error.message, {
                                 code: 'VALIDATION_ERROR',
                                 status: 400
                             })
                         }
-                    })
+                        // Apply Joi defaults (e.g., .default() values) back to data
+                        options.data[i] = validationResult.value
+                    }
                 }
 
                 if (options.action == 'insertOne') {
-                    validationResult = schema.validate(options.data, {
-                        allowUnknown: false,
-                    })
+                    validationResult = schema.validate(options.data, { allowUnknown: false })
+                    if (validationResult?.error) {
+                        throw new AppError(validationResult.error.message, {
+                            code: 'VALIDATION_ERROR',
+                            status: 400
+                        })
+                    }
+                    // Persist Joi defaults back to data
+                    if (validationResult.value) options.data = validationResult.value
                 }
             }
 
 
             if (options?.update) {
-                if (options.action == 'insertOne' && options.update?.$set) {
-                    validationResult = partialSchema.validate(options.update?.$set, {
-                        allowUnknown: false,
-                    })
-                }
-
-                if (options.action == 'insertMany' && options.update?.$set) {
-                    validationResult = partialSchema.validate(options.update?.$set, {
-                        allowUnknown: false,
-                    })
+                if ((options.action == 'insertOne' || options.action == 'insertMany') && options.update?.$set) {
+                    validationResult = partialSchema.validate(options.update.$set, { allowUnknown: false })
                 }
 
                 if (options.action == "findOneAndUpdate" && options.update.$set) {
-                    validationResult = partialSchema.validate(options.update.$set, {
-                        allowUnknown: false,
-                    })
+                    validationResult = partialSchema.validate(options.update.$set, { allowUnknown: false })
                 }
 
                 if (options.action == "findOneAndUpdate" && options.update.$setOnInsert) {
-                    validationResult = partialSchema.validate(options.update.$setOnInsert, {
-                        allowUnknown: false,
-                    })
+                    validationResult = partialSchema.validate(options.update.$setOnInsert, { allowUnknown: false })
                 }
-            }
 
-            if (validationResult?.error) {
-                throw new AppError(validationResult.error.message, {
-                    code: 'VALIDATION_ERROR',
-                    status: 400
-                })
+                if (validationResult?.error) {
+                    throw new AppError(validationResult.error.message, {
+                        code: 'VALIDATION_ERROR',
+                        status: 400
+                    })
+                }
             }
 
         }
+    }
 
 
 
@@ -371,18 +356,19 @@ class MongoRest {
             data = await func.buildInput(data as T, {
                 action: action, col: col, rest: this
             })
-            this._validate({ collection, action: action, data: data })
 
             const meta: any = { action, collection, data }
             if (col.hooks?.beforeOperation) {
                 await col.hooks.beforeOperation({ rest: this, io, action, meta })
             }
+            // Validate AFTER hooks (they may fill required fields or apply Joi defaults)
+            this._validate({ collection, action: action, data: meta.data })
 
-            await this.db.collection(collection).insertOne(func.toBson(data, { col }) as any, {
+            await this.db.collection(collection).insertOne(func.toBson(meta.data, { col }) as any, {
                 session: this.session,
             })
 
-            const result: T & { _id: string } = func.toJson(data as T & { _id: string })
+            const result: T & { _id: string } = func.toJson(meta.data as T & { _id: string })
             meta.result = result
             if (col?.hooks?.afterOperation) {
                 await col.hooks.afterOperation({ rest: this, io, action, meta })
@@ -409,18 +395,18 @@ class MongoRest {
                 dataInput.push(d)
             }
 
-            this._validate({ collection, action: action, data: dataInput })
-
             const meta: any = { action, collection, data: dataInput }
             if (col.hooks?.beforeOperation) {
                 await col.hooks.beforeOperation({ rest: this, io, action, meta })
             }
+            // Validate AFTER hooks (they may fill required fields or apply Joi defaults)
+            this._validate({ collection, action: action, data: meta.data })
 
-            await this.db.collection(collection).insertMany(func.toBson(dataInput, { col }) as any, {
+            await this.db.collection(collection).insertMany(func.toBson(meta.data, { col }) as any, {
                 session: this.session,
             })
 
-            const result: (T & { _id: string })[] = func.toJson(dataInput as (T & { _id: string })[])
+            const result: (T & { _id: string })[] = func.toJson(meta.data as (T & { _id: string })[])
             meta.result = result
 
             if (col.hooks?.afterOperation) {
@@ -443,13 +429,15 @@ class MongoRest {
             }
 
             update = await func.buildInput(update)
-            this._validate({ collection, action: action, update: update })
-            update = func.toBson(update, { col })
 
             const meta: any = { action, collection, update, id: _id }
             if (col.hooks?.beforeOperation) {
                 await col.hooks.beforeOperation({ rest: this, io, action, meta })
             }
+            // Validate and toBson AFTER hooks
+            update = meta.update;
+            this._validate({ collection, action: action, update: update })
+            update = func.toBson(update, { col })
 
             const data = await this.db.collection(collection).findOneAndUpdate(
                 { _id: new ObjectId(_id) },
@@ -505,15 +493,17 @@ class MongoRest {
             }
 
 
-            this._validate({ collection, action: action, update: update.$set })
-            this._validate({ collection, action: action, update: update.$setOnInsert })
-            update = func.toBson(update, { col })
-            filter = func.toBson(filter, { col })
-
             const meta: any = { action, collection, filter, update }
             if (col.hooks?.beforeOperation) {
                 await col.hooks.beforeOperation({ rest: this, io, action, meta })
             }
+            // Validate and toBson AFTER hooks
+            update = meta.update;
+            filter = meta.filter;
+            this._validate({ collection, action: action, update: update.$set })
+            this._validate({ collection, action: action, update: update.$setOnInsert })
+            update = func.toBson(update, { col })
+            filter = func.toBson(filter, { col })
 
             const data = await this.db.collection(collection).findOneAndUpdate(
                 filter,
@@ -546,13 +536,15 @@ class MongoRest {
                 update.$set = await func.buildInput(update.$set, { action: action, col: col })
             }
             update = await func.buildInput(update)
-            this._validate({ collection, action: action, update: update })
-            update = func.toBson(update, { col })
 
             const meta: any = { action, collection, update, ids: _ids }
             if (col.hooks?.beforeOperation) {
                 await col.hooks.beforeOperation({ rest: this, io, action, meta })
             }
+            // Validate and toBson AFTER hooks
+            update = meta.update;
+            this._validate({ collection, action: action, update: update })
+            update = func.toBson(update, { col })
 
             const result = await this.db.collection(collection).updateMany(
                 { _id: { $in: _ids.map(id => new ObjectId(id)) } },

package/package.json

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

package/server/boot.ts

@@ -17,6 +17,19 @@ import { loadServices } from '../lib/services'
 import { loadSockets } from '../lib/sockets'
 import { syncWorkflows } from '../lib/workflow'
 import { loadTenantsMiddlewares } from '../lib/middleware'
+
+/** 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;
+    }
+}
+
 type BootAppOptions = ServerConfig & {
 
 }
@@ -38,17 +51,51 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
         //******************************* */
 
 
+        // JWT_SECRET check: auto-generate if missing and auth is enabled
+        const hasAuth = cfg.collections?.some((c: any) => c.api?.auth?.enabled);
+        let jwtSecret = cfg.server.jwt?.secret || Bun.env.JWT_SECRET;
+        if (hasAuth && !jwtSecret) {
+            jwtSecret = Array.from({ length: 64 }, () =>
+                'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'[Math.floor(Math.random() * 64)]
+            ).join('');
+            try {
+                const envPath = '.env';
+                const exists = await Bun.file(envPath).exists();
+                const content = exists ? await Bun.file(envPath).text() : '';
+                if (!content.includes('JWT_SECRET=')) {
+                    const suffix = content ? '\n' : '';
+                    await Bun.write(envPath, `${content}${suffix}# Auto-generated on boot\nJWT_SECRET=${jwtSecret}\n`);
+                }
+                Bun.env.JWT_SECRET = jwtSecret;
+                console.log('🔐 JWT_SECRET auto-generated and saved to .env'.gray);
+            } catch {
+                Bun.env.JWT_SECRET = jwtSecret;
+                console.log('⚠ JWT_SECRET auto-generated (in-memory only, could not write .env)'.yellow);
+            }
+        }
+
         const PORT = (cfg.server.port || 4000);
         const NAME = cfg.server.name || process.env.APP_NAME || 'SERVER';
         const useClusterMode = cfg.clusterMode || false;
         const env = process.env.NODE_ENV || Bun.env.NODE_ENV || 'dev';
+        // reusePort: cluster mode ON by default, dev mode OFF to detect zombies
+        const reusePort = cfg.server.reusePort ?? (useClusterMode && env !== 'dev');
+
+        // Detect zombie: check if port is already in use in dev mode
+        if (!reusePort && env === 'dev') {
+            const occupied = await isPortInUse(PORT);
+            if (occupied) {
+                console.error(`\n⚠ Port ${PORT} is already in use. Possible zombie server.\n  → Kill it: lsof -ti :${PORT} | xargs kill -9\n  → Or set server.reusePort: true in config\n`.red.bold);
+                process.exit(1);
+            }
+        }
 
 
         const app = createApp();
 
         const server = Bun.serve({
             port: PORT,
-            reusePort: useClusterMode,
+            reusePort,
             fetch: (req, server) => {
                 const url = new URL(req.url);
 

package/types/collection.d.ts

@@ -70,6 +70,8 @@ export type Collection = {
      */
     _tenant_?: string;
     _isTimeSerie_?: boolean;
+    /** Drop MongoDB indexes for fields no longer in the schema (default: false) */
+    purgeOrphanIndexes?: boolean;
     _isCollection_?: boolean;
     _schema_?: Joi.Schema;
     _schemaPartial_?: Joi.Schema;

package/types/config.d.ts

@@ -13,6 +13,7 @@ export type ServerConfig = {
     server: {
         name?: string;
         port: number;
+        reusePort?: boolean;  // override Bun's reusePort (default: clusterMode && not dev)
         body?: {
             maxSize?: number;
         };

package/utils/func.ts

@@ -372,7 +372,10 @@ function formatToObjectId<T>(value: T): FormatToObjectIdResult<T> {
         return value as FormatToObjectIdResult<T>;
     }
 
-
+    // Pass through primitives and Date instances untouched
+    if (value instanceof Date) {
+        return value as FormatToObjectIdResult<T>;
+    }
 
     if (typeof value === 'string') {
 
@@ -608,7 +611,15 @@ function collectDateFieldPathsFromCollection(col: Collection): string[] {
 
 function toBson<T>(data: any | any[], _options?: FormatInputOptions): T {
     let data_ = formatToObjectId(data);
-    data_ = formatToDate(data_);
+
+    // Build omitKeys for fields that should NOT be date-converted (random, number, integer)
+    const omitKeys: string[] = [];
+    for (const f of _options?.col?.fields ?? []) {
+        if (f.type === 'random' || f.type === 'number' || f.type === 'integer') {
+            omitKeys.push(f.name);
+        }
+    }
+    data_ = formatToDate(data_, { omitKeys: omitKeys.length > 0 ? omitKeys : undefined });
 
     if (Array.isArray(data)) {
         data.length = 0;