@airoom/nextmin-node 1.4.6 → 2.0.1

package/dist/database/MongoAdapter.js

@@ -1,410 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoAdapter = void 0;
-const mongoose_1 = __importStar(require("mongoose"));
-const mongoose_autopopulate_1 = __importDefault(require("mongoose-autopopulate"));
-const Logger_1 = __importDefault(require("../utils/Logger"));
-const SchemaLoader_1 = require("../utils/SchemaLoader");
-// Prevent Mongoose from pluralizing model names automatically
-mongoose_1.default.pluralize(null);
-class MongoAdapter {
-    constructor(url, dbName) {
-        this.url = url;
-        this.dbName = dbName;
-        this.connection = mongoose_1.default.createConnection(`${this.url}/${this.dbName}`);
-        this.models = new Map();
-    }
-    async connect() {
-        await this.connection.asPromise();
-        Logger_1.default.info('MongoAdapter', `Connected to MongoDB database: ${this.dbName}`);
-    }
-    async disconnect() {
-        await this.connection.close();
-        Logger_1.default.warn('MongoAdapter', 'Disconnected from MongoDB database');
-    }
-    /**
-     * Register (and re-register) all schemas.
-     * - Drops compiled models that no longer exist.
-     * - Recompiles every current model so validators reflect latest schema.
-     */
-    async registerSchemas(schemas) {
-        // Build the incoming set from schema.modelName (not object keys!)
-        const incoming = new Set(Object.values(schemas).map((s) => s.modelName.toLowerCase()));
-        // 1) Remove compiled models that are no longer present
-        for (const name of Array.from(this.models.keys())) {
-            if (!incoming.has(name)) {
-                this.safeDeleteModel(name);
-                this.models.delete(name);
-                // Optional: also drop the collection (disabled by default)
-                // await this.safeDropCollection(name);
-            }
-        }
-        // 2) (Re)compile every current model so validators and fields are fresh
-        for (const def of Object.values(schemas)) {
-            const modelKey = def.modelName; // e.g. "Users"
-            const modelKeyLc = modelKey.toLowerCase();
-            const collection = def.collection?.toLowerCase() ?? modelKeyLc; // e.g. "users"
-            // always delete previous compiled model to avoid OverwriteModelError and stale validators
-            this.safeDeleteModel(modelKey);
-            const mSchema = this.buildMongooseSchema(def);
-            const model = this.connection.model(modelKey, mSchema, collection);
-            this.models.set(modelKeyLc, model);
-        }
-    }
-    /** Optional hook used by the router when schemas are removed. */
-    async unregisterSchemas(names) {
-        for (const raw of names) {
-            const lc = raw.toLowerCase();
-            this.safeDeleteModel(lc);
-            this.models.delete(lc);
-            // Optional: await this.safeDropCollection(lc);
-        }
-    }
-    /** Optional single-model drop hook. */
-    async dropModel(nameRaw) {
-        const lc = nameRaw.toLowerCase();
-        this.safeDeleteModel(lc);
-        this.models.delete(lc);
-        // Optional: await this.safeDropCollection(lc);
-    }
-    // ---------------- Internals ----------------
-    /**
-     * Delete a compiled model by case-insensitive match.
-     * Works whether we compiled it as "Users" or "users".
-     */
-    safeDeleteModel(nameOrLc) {
-        try {
-            const targetLc = nameOrLc.toLowerCase();
-            const keys = Object.keys(this.connection.models);
-            for (const k of keys) {
-                if (k.toLowerCase() === targetLc) {
-                    this.connection.deleteModel(k);
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    async safeDropCollection(name) {
-        try {
-            await this.connection.dropCollection(name);
-        }
-        catch (e) {
-            // ignore "ns not found" etc.
-            if (e?.codeName !== 'NamespaceNotFound') {
-                Logger_1.default.warn('MongoAdapter', `dropCollection(${name}) warning:`, e?.message || e);
-            }
-        }
-    }
-    /** Build a fresh Mongoose schema from our NextMin schema definition. */
-    buildMongooseSchema(def) {
-        const shape = {};
-        // If this schema extends a base, only include child-own attributes for storage
-        let baseKeys = null;
-        const baseName = def?.extends;
-        if (baseName) {
-            const baseSchema = this.getSchema(baseName);
-            if (baseSchema) {
-                baseKeys = new Set(Object.keys(baseSchema.attributes || {}));
-            }
-        }
-        for (const [key, attr] of Object.entries(def.attributes)) {
-            // Exclude base attributes from child storage schema; always allow link field
-            if (baseKeys && key !== 'baseId' && baseKeys.has(key))
-                continue;
-            shape[key] = this.mapAttribute(attr);
-        }
-        const s = new mongoose_1.Schema(shape, { timestamps: true });
-        // Hide private fields by default when toObject() is used (unless overridden)
-        s.set('toObject', {
-            transform: (_doc, ret) => {
-                for (const [key, attr] of Object.entries(def.attributes)) {
-                    if (!Array.isArray(attr) && attr.private) {
-                        delete ret[key];
-                    }
-                }
-                return ret;
-            },
-        });
-        s.plugin(mongoose_autopopulate_1.default);
-        return s;
-    }
-    mapAttribute(attribute) {
-        // Arrays
-        if (Array.isArray(attribute)) {
-            const elem = attribute[0] || { type: 'string' };
-            const mapped = this.mapScalar(elem);
-            // Mongoose "array of refs" works best as [{ type: X, ref: 'Y', autopopulate: true }]
-            const arrItem = { ...mapped };
-            // required belongs on the path, not the inner type
-            const required = !!elem.required;
-            delete arrItem.required;
-            return { type: [arrItem], required };
-        }
-        // Single
-        return this.mapScalar(attribute);
-    }
-    mapScalar(attr) {
-        const typeMapping = {
-            string: String,
-            number: Number,
-            boolean: Boolean,
-            date: Date,
-            array: Array,
-            object: Object,
-            objectid: mongoose_1.default.Schema.Types.ObjectId,
-        };
-        const out = {
-            type: typeMapping[String(attr?.type || 'string').toLowerCase()] || String,
-        };
-        // Only set when truthy to avoid forcing behavior when unset
-        if (attr?.required === true)
-            out.required = true;
-        if (attr?.unique === true)
-            out.unique = true;
-        if (attr?.ref) {
-            out.ref = attr.ref;
-            out.autopopulate = true;
-        }
-        if (attr?.default !== undefined) {
-            if (String(attr.type).toLowerCase() === 'date' &&
-                attr.default === 'now') {
-                out.default = Date.now;
-            }
-            else {
-                out.default = attr.default;
-            }
-        }
-        // Optional common validators
-        if (attr?.enum)
-            out.enum = attr.enum;
-        if (attr?.min !== undefined)
-            out.min = attr.min;
-        if (attr?.max !== undefined)
-            out.max = attr.max;
-        if (attr?.minLength !== undefined)
-            out.minLength = attr.minLength;
-        if (attr?.maxLength !== undefined)
-            out.maxLength = attr.maxLength;
-        if (attr?.match)
-            out.match = new RegExp(attr.match);
-        return out;
-    }
-    /**
-     * Resolve (or lazily create) the compiled model for a schema.
-     * Uses schema.modelName as the Mongoose model name and
-     * (schema.collection ?? modelName).toLowerCase() as the collection.
-     */
-    getModel(collection, schemaDefinition) {
-        const modelKey = schemaDefinition.modelName; // e.g. "Users"
-        const modelKeyLc = modelKey.toLowerCase();
-        const collectionName = schemaDefinition.collection?.toLowerCase() ??
-            collection.toLowerCase();
-        // Prefer cached by lowercased model key
-        const cached = this.models.get(modelKeyLc);
-        if (cached)
-            return cached;
-        // Ensure any dependency (rare) – preserved from your original example
-        if (schemaDefinition.attributes.author?.ref === 'Users') {
-            const userSchema = this.getSchema('Users');
-            if (!userSchema)
-                throw new Error(`Missing schema for Users`);
-            if (!this.models.has('users')) {
-                const uModel = this.connection.model(userSchema.modelName, this.buildMongooseSchema(userSchema), userSchema.collection?.toLowerCase() ??
-                    userSchema.modelName.toLowerCase());
-                this.models.set('users', uModel);
-            }
-        }
-        // Remove any stale compiled model(s) with same name (case-insensitive), then (re)create
-        this.safeDeleteModel(modelKey);
-        const model = this.connection.model(modelKey, this.buildMongooseSchema(schemaDefinition), collectionName);
-        this.models.set(modelKeyLc, model);
-        return model;
-    }
-    getSchema(modelName) {
-        // Use the singleton loader so we read the same live map as the router
-        const loader = SchemaLoader_1.SchemaLoader.getInstance?.() ?? new SchemaLoader_1.SchemaLoader();
-        const schemas = loader.getSchemas();
-        // The loader returns a map keyed by modelName; prefer lookup by value
-        const byName = Object.values(schemas).find((s) => String(s.modelName).toLowerCase() === modelName.toLowerCase());
-        return byName;
-    }
-    convertQueryFieldsToObjectId(query, schemaDefinition) {
-        const newQuery = { ...query };
-        // Remap 'id' to '_id'
-        if (newQuery.id !== undefined) {
-            try {
-                newQuery._id = new mongoose_1.default.Types.ObjectId(String(newQuery.id));
-            }
-            catch {
-                // leave as-is if not a valid ObjectId
-                newQuery._id = newQuery.id;
-            }
-            delete newQuery.id;
-        }
-        // Convert any fields defined as objectid
-        for (const [key, attribute] of Object.entries(schemaDefinition.attributes)) {
-            if (!Array.isArray(attribute) &&
-                String(attribute.type || '').toLowerCase() === 'objectid') {
-                const val = newQuery[key];
-                if (val === undefined || val === null)
-                    continue;
-                const toObjectId = (v) => {
-                    try {
-                        return new mongoose_1.default.Types.ObjectId(String(v));
-                    }
-                    catch {
-                        Logger_1.default.warn('MongoAdapter', `Invalid ObjectId for '${key}': ${v}`);
-                        return v;
-                    }
-                };
-                if (Array.isArray(val)) {
-                    newQuery[key] = val.map(toObjectId);
-                }
-                else {
-                    newQuery[key] = toObjectId(val);
-                }
-            }
-        }
-        return newQuery;
-    }
-    toAppObject(doc, includePrivateFields) {
-        if (!doc)
-            return doc;
-        const obj = doc.toObject(includePrivateFields
-            ? { transform: (_doc, ret) => ret } // override to keep private fields
-            : undefined);
-        if (obj?._id !== undefined) {
-            obj.id = String(obj._id);
-            delete obj._id;
-        }
-        if ('__v' in obj)
-            delete obj.__v;
-        return obj;
-    }
-    // ---------------- CRUD ----------------
-    async create(collection, data, schemaDefinition, includePrivateFields = false) {
-        const model = this.getModel(collection, schemaDefinition);
-        const doc = new model(data);
-        const saved = await doc.save();
-        return this.toAppObject(saved, includePrivateFields);
-    }
-    async read(collection, query, limit, skip, schemaDefinition, includePrivateFields, options) {
-        const model = this.getModel(collection, schemaDefinition);
-        const q = this.convertQueryFieldsToObjectId(query, schemaDefinition);
-        let cursor = model.find(q, options?.projection); // ✅ projection support (optional)
-        if (options?.sort && Object.keys(options.sort).length) {
-            cursor = cursor.sort(options.sort); // ✅ apply sort
-        }
-        if (limit !== undefined && skip !== undefined) {
-            cursor = cursor.limit(limit).skip(skip);
-        }
-        const results = await cursor.exec();
-        return results.map((doc) => this.toAppObject(doc, includePrivateFields));
-    }
-    async count(collection, query, schemaDefinition) {
-        const model = this.getModel(collection, schemaDefinition);
-        const q = this.convertQueryFieldsToObjectId(query, schemaDefinition);
-        return model.countDocuments(q).exec();
-    }
-    async update(collection, id, data, schemaDefinition, includePrivateFields) {
-        const model = this.getModel(collection, schemaDefinition);
-        const { _id } = this.convertQueryFieldsToObjectId({ id }, schemaDefinition);
-        const updated = await model
-            .findByIdAndUpdate(_id, data, { new: true, runValidators: true })
-            .exec();
-        if (!updated) {
-            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
-        }
-        return this.toAppObject(updated, includePrivateFields);
-    }
-    async delete(collection, id, schemaDefinition, includePrivateFields = false) {
-        const model = this.getModel(collection, schemaDefinition);
-        const { _id } = this.convertQueryFieldsToObjectId({ id }, schemaDefinition);
-        const deleted = await model.findByIdAndDelete(_id).exec();
-        if (!deleted) {
-            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
-        }
-        return this.toAppObject(deleted, includePrivateFields);
-    }
-    getNativeCollectionByModelName(modelName) {
-        const s = this.getSchema(modelName);
-        if (!s)
-            throw new Error(`Schema not found for ${modelName}`);
-        const collName = s.collection?.toLowerCase?.() ?? s.modelName.toLowerCase();
-        // returns the MongoDB driver's Collection (not a Mongoose Model)
-        return this.connection.collection(collName);
-    }
-    /** Create/drop single-field indexes based on schema plan.
-     *  Only touches indexes named with the prefix below (won't touch user indexes).
-     */
-    managedIndexName(field) {
-        return `nextmin_idx_${field}`;
-    }
-    async syncIndexes(modelName, spec) {
-        const col = this.getNativeCollectionByModelName(modelName);
-        const existing = await col.indexes(); // [{ name, key, unique, sparse, ... }]
-        // desired => only from 'spec'
-        const desired = Object.entries(spec).map(([field, dir]) => ({
-            name: `${field}_${dir === 1 ? 'asc' : 'desc'}`,
-            key: { [field]: dir },
-        }));
-        const desiredNames = new Set(desired.map((d) => d.name));
-        // drop indexes not in desired (except _id_)
-        for (const idx of existing) {
-            if (idx.name === '_id_')
-                continue;
-            if (!desiredNames.has(idx.name)) {
-                try {
-                    await col.dropIndex(idx.name);
-                }
-                catch { }
-            }
-        }
-        // create missing
-        const existingNames = new Set((await col.indexes()).map((i) => i.name));
-        for (const d of desired) {
-            if (!existingNames.has(d.name)) {
-                await col.createIndex(d.key, { name: d.name });
-            }
-        }
-    }
-}
-exports.MongoAdapter = MongoAdapter;