uql-orm 0.7.5 → 0.7.9

package/dist/browser/mongoSchemaGenerator-B1IameRz.js

@@ -0,0 +1,721 @@
+import { getMeta } from '../entity/index.js';
+import { ObjectId } from 'mongodb';
+import { buildQueryWhereAsMap, buildSortMap, hasKeys, filterRelationKeys, getKeys, fillOnFields, filterFieldKeys, parseGroupMap, isVectorSearch } from '../util/index.js';
+
+/**
+ * Merge dialect capability defaults with optional overrides from {@link DialectOptions.driverCapabilities}.
+ */ function mergeDialectFeatures(defaults, patch) {
+    return patch ? {
+        ...defaults,
+        ...patch
+    } : defaults;
+}
+/**
+ * Base abstract class for all database dialects (SQL and NoSQL).
+ */ class AbstractDialect {
+    constructor(featureDefaults, options = {}){
+        this.options = options;
+        this.namingStrategy = options.namingStrategy;
+        this.features = mergeDialectFeatures(featureDefaults, options.driverCapabilities);
+    }
+    /**
+   * Resolve the table name for an entity, applying naming strategy if necessary.
+   */ resolveTableName(entity, meta) {
+        const name = meta.name ?? entity.name;
+        if (name !== entity.name || !this.namingStrategy) {
+            return name;
+        }
+        return this.namingStrategy.tableName(name);
+    }
+    /**
+   * Resolve the column/field name for a property, applying naming strategy if necessary.
+   */ resolveColumnName(key, field) {
+        if (!field || field.name !== key || !this.namingStrategy) {
+            return field?.name ?? key;
+        }
+        return this.namingStrategy.columnName(field.name);
+    }
+}
+
+class MongoDialect extends AbstractDialect {
+    static{
+        /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoSchemaGenerator}. */ this.defaultDialectFeatures = {
+            explicitJsonCast: false,
+            nativeArrays: false,
+            supportsJsonb: false,
+            returning: false,
+            ifNotExists: false,
+            indexIfNotExists: false,
+            dropTableCascade: false,
+            renameColumn: false,
+            foreignKeyAlter: false,
+            columnComment: false,
+            vectorIndexStyle: 'create',
+            vectorSupportsLength: false,
+            supportsTimestamptz: false,
+            defaultStringAsText: false
+        };
+    }
+    constructor(options = {}){
+        super(MongoDialect.defaultDialectFeatures, options), this.dialectName = 'mongodb', this.insertIdStrategy = 'last';
+    }
+    static{
+        this.ID_KEY = '_id';
+    }
+    static{
+        this.VECTOR_INDEX_TYPES = new Set([
+            'vectorSearch',
+            'hnsw',
+            'ivfflat',
+            'vector'
+        ]);
+    }
+    static{
+        this.AGGREGATE_OP_MAP = {
+            $count: '$sum',
+            $sum: '$sum',
+            $avg: '$avg',
+            $min: '$min',
+            $max: '$max'
+        };
+    }
+    where(entity, where = {}, { softDelete } = {}) {
+        const meta = getMeta(entity);
+        const whereMap = buildQueryWhereAsMap(meta, where);
+        if (meta.softDelete && (softDelete || softDelete === undefined) && !whereMap[meta.softDelete]) {
+            const field = meta.fields[meta.softDelete];
+            whereMap[this.resolveColumnName(meta.softDelete, field)] = null;
+        }
+        const filter = {};
+        for (const [rawKey, rawVal] of Object.entries(whereMap)){
+            let key = rawKey;
+            let val = rawVal;
+            if (key === '$and' || key === '$or') {
+                filter[key] = val.map((filterIt)=>this.where(entity, filterIt));
+            } else {
+                const field = meta.fields[key];
+                if (key === MongoDialect.ID_KEY || key === meta.id) {
+                    key = MongoDialect.ID_KEY;
+                    val = this.getIdValue(val);
+                } else if (field) {
+                    key = this.resolveColumnName(key, field);
+                }
+                if (val && typeof val === 'object' && !Array.isArray(val) && this.hasOperatorKeys(val)) {
+                    val = this.transformOperators(val);
+                } else if (Array.isArray(val)) {
+                    val = {
+                        $in: val
+                    };
+                }
+                filter[key] = val;
+            }
+        }
+        return filter;
+    }
+    /**
+   * Check if an object has operator keys (keys starting with $).
+   */ hasOperatorKeys(obj) {
+        return Object.keys(obj).some((key)=>key.startsWith('$'));
+    }
+    mapTableNameRow(row) {
+        return row.table_name;
+    }
+    static{
+        /** String operators → { pattern: (v) => regex, caseInsensitive } */ this.REGEX_OP_MAP = {
+            $startsWith: {
+                wrap: (v)=>`^${v}`,
+                ci: false
+            },
+            $istartsWith: {
+                wrap: (v)=>`^${v}`,
+                ci: true
+            },
+            $endsWith: {
+                wrap: (v)=>`${v}$`,
+                ci: false
+            },
+            $iendsWith: {
+                wrap: (v)=>`${v}$`,
+                ci: true
+            },
+            $includes: {
+                wrap: (v)=>String(v),
+                ci: false
+            },
+            $iincludes: {
+                wrap: (v)=>String(v),
+                ci: true
+            },
+            $like: {
+                wrap: (v)=>String(v).replace(/%/g, '.*').replace(/_/g, '.'),
+                ci: false
+            },
+            $ilike: {
+                wrap: (v)=>String(v).replace(/%/g, '.*').replace(/_/g, '.'),
+                ci: true
+            }
+        };
+    }
+    static{
+        /** MongoDB native operators — pass through as-is. */ this.NATIVE_OPS = new Set([
+            '$all',
+            '$size',
+            '$elemMatch',
+            '$eq',
+            '$ne',
+            '$lt',
+            '$lte',
+            '$gt',
+            '$gte',
+            '$in',
+            '$nin',
+            '$regex',
+            '$not'
+        ]);
+    }
+    /**
+   * Transform UQL operators to MongoDB operators.
+   */ transformOperators(ops) {
+        const result = {};
+        for (const [op, val] of Object.entries(ops)){
+            // Native MongoDB operators — pass through directly
+            if (MongoDialect.NATIVE_OPS.has(op)) {
+                result[op] = val;
+                continue;
+            }
+            // String/pattern → regex operators (8 variants including $like/$ilike)
+            const regexEntry = MongoDialect.REGEX_OP_MAP[op];
+            if (regexEntry) {
+                result['$regex'] = regexEntry.wrap(val);
+                if (regexEntry.ci) result['$options'] = 'i';
+                continue;
+            }
+            // Structural transforms
+            switch(op){
+                case '$between':
+                    {
+                        const [min, max] = val;
+                        result['$gte'] = min;
+                        result['$lte'] = max;
+                        break;
+                    }
+                case '$isNull':
+                    result[val ? '$eq' : '$ne'] = null;
+                    break;
+                case '$isNotNull':
+                    result[val ? '$ne' : '$eq'] = null;
+                    break;
+                case '$text':
+                    result['$text'] = {
+                        $search: val
+                    };
+                    break;
+                default:
+                    result[op] = val;
+                    break;
+            }
+        }
+        return result;
+    }
+    select(entity, select) {
+        return select;
+    }
+    sort(entity, sort) {
+        const raw = buildSortMap(sort);
+        const normalized = {};
+        for (const [key, dir] of Object.entries(raw)){
+            normalized[key] = dir === 'desc' || dir === -1 ? -1 : 1;
+        }
+        return normalized;
+    }
+    aggregationPipeline(entity, q) {
+        const meta = getMeta(entity);
+        const where = this.where(entity, q.$where);
+        const sort = this.sort(entity, q.$sort);
+        const firstPipelineEntry = {};
+        if (hasKeys(where)) {
+            firstPipelineEntry.$match = where;
+        }
+        if (hasKeys(sort)) {
+            firstPipelineEntry.$sort = sort;
+        }
+        const pipeline = [];
+        if (hasKeys(firstPipelineEntry)) {
+            pipeline.push(firstPipelineEntry);
+        }
+        const relKeys = filterRelationKeys(meta, q.$select);
+        for (const relKey of relKeys){
+            const relOpts = meta.relations[relKey];
+            if (!relOpts) continue;
+            if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {
+                continue;
+            }
+            const relEntity = relOpts.entity();
+            const relMeta = getMeta(relEntity);
+            if (relOpts.cardinality === 'm1') {
+                const localField = meta.fields[relOpts.references[0].local];
+                pipeline.push({
+                    $lookup: {
+                        from: this.resolveTableName(relEntity, relMeta),
+                        localField: this.resolveColumnName(relOpts.references[0].local, localField),
+                        foreignField: '_id',
+                        as: relKey
+                    }
+                });
+            } else {
+                const foreignField = relMeta.fields[relOpts.references[0].foreign];
+                const foreignFieldName = this.resolveColumnName(relOpts.references[0].foreign, foreignField);
+                const referenceWhere = this.where(relEntity, where);
+                const referenceSort = this.sort(relEntity, q.$sort);
+                const _id = MongoDialect.ID_KEY;
+                const referencePipelineEntry = {
+                    $match: {
+                        [foreignFieldName]: referenceWhere[_id]
+                    }
+                };
+                if (hasKeys(referenceSort)) {
+                    referencePipelineEntry.$sort = referenceSort;
+                }
+                pipeline.push({
+                    $lookup: {
+                        from: this.resolveTableName(relEntity, relMeta),
+                        pipeline: [
+                            referencePipelineEntry
+                        ],
+                        as: relKey
+                    }
+                });
+            }
+            pipeline.push({
+                $unwind: {
+                    path: `$${relKey}`,
+                    preserveNullAndEmptyArrays: true
+                }
+            });
+        }
+        return pipeline;
+    }
+    normalizeIds(meta, docs) {
+        return docs?.map((doc)=>this.normalizeId(meta, doc));
+    }
+    normalizeId(meta, doc) {
+        if (!doc) {
+            return doc;
+        }
+        const res = doc;
+        const _id = MongoDialect.ID_KEY;
+        if (res[_id]) {
+            res[meta.id] = res[_id];
+            if (meta.id !== _id) {
+                delete res[_id];
+            }
+        }
+        for (const key of getKeys(meta.fields)){
+            const field = meta.fields[key];
+            const dbName = this.resolveColumnName(key, field);
+            if (dbName !== key && res[dbName] !== undefined) {
+                res[key] = res[dbName];
+                delete res[dbName];
+            }
+        }
+        const relKeys = getKeys(meta.relations).filter((key)=>res[key]);
+        for (const relKey of relKeys){
+            const relOpts = meta.relations[relKey];
+            if (!relOpts) continue;
+            const relMeta = getMeta(relOpts.entity());
+            res[relKey] = Array.isArray(res[relKey]) ? this.normalizeIds(relMeta, res[relKey]) : this.normalizeId(relMeta, res[relKey]);
+        }
+        return res;
+    }
+    getIdValue(value) {
+        if (value instanceof ObjectId) {
+            return value;
+        }
+        try {
+            return new ObjectId(value);
+        } catch (e) {
+            return value;
+        }
+    }
+    getPersistable(meta, payload, callbackKey) {
+        return this.getPersistables(meta, payload, callbackKey)[0];
+    }
+    getPersistables(meta, payload, callbackKey) {
+        const payloads = fillOnFields(meta, payload, callbackKey);
+        const persistableKeys = filterFieldKeys(meta, payloads[0], callbackKey);
+        return payloads.map((it)=>persistableKeys.reduce((acc, key)=>{
+                const field = meta.fields[key];
+                acc[this.resolveColumnName(key, field)] = it[key];
+                return acc;
+            }, {}));
+    }
+    /**
+   * Build MongoDB aggregation pipeline stages from a QueryAggregate.
+   */ buildAggregateStages(entity, q) {
+        const pipeline = [];
+        // $match stage (WHERE equivalent — before grouping)
+        if (q.$where) {
+            const filter = this.where(entity, q.$where);
+            if (hasKeys(filter)) {
+                pipeline.push({
+                    $match: filter
+                });
+            }
+        }
+        // $group stage
+        const groupId = {};
+        const groupAccumulators = {};
+        for (const entry of parseGroupMap(q.$group)){
+            if (entry.kind === 'key') {
+                groupId[entry.alias] = `$${entry.alias}`;
+            } else {
+                const mongoOp = MongoDialect.AGGREGATE_OP_MAP[entry.op];
+                groupAccumulators[entry.alias] = entry.op === '$count' ? {
+                    [mongoOp]: 1
+                } : {
+                    [mongoOp]: `$${entry.fieldRef}`
+                };
+            }
+        }
+        pipeline.push({
+            $group: {
+                _id: hasKeys(groupId) ? groupId : null,
+                ...groupAccumulators
+            }
+        });
+        // Project stage — rename _id fields back to their original names
+        if (hasKeys(groupId)) {
+            const project = {
+                _id: 0
+            };
+            for (const alias of Object.keys(groupId)){
+                project[alias] = `$_id.${alias}`;
+            }
+            for (const alias of Object.keys(groupAccumulators)){
+                project[alias] = 1;
+            }
+            pipeline.push({
+                $project: project
+            });
+        }
+        // $match stage for HAVING (post-group filtering)
+        if (q.$having) {
+            const havingFilter = this.buildHavingFilter(q.$having);
+            if (hasKeys(havingFilter)) {
+                pipeline.push({
+                    $match: havingFilter
+                });
+            }
+        }
+        // $sort stage
+        if (q.$sort) {
+            const sort = this.sort(entity, q.$sort);
+            if (hasKeys(sort)) {
+                pipeline.push({
+                    $sort: sort
+                });
+            }
+        }
+        // $skip and $limit stages
+        if (q.$skip !== undefined) {
+            pipeline.push({
+                $skip: q.$skip
+            });
+        }
+        if (q.$limit !== undefined) {
+            pipeline.push({
+                $limit: q.$limit
+            });
+        }
+        return pipeline;
+    }
+    buildHavingFilter(having) {
+        const filter = {};
+        for (const [alias, condition] of Object.entries(having)){
+            if (condition === undefined) continue;
+            if (typeof condition === 'number') {
+                filter[alias] = condition;
+            } else if (typeof condition === 'object' && condition !== null) {
+                filter[alias] = this.transformOperators(condition);
+            }
+        }
+        return filter;
+    }
+    /**
+   * Separate vector sort entries from regular sort entries.
+   * Returns `undefined` if no vector sort is present.
+   */ extractVectorSort(sort) {
+        if (!sort) return undefined;
+        const raw = buildSortMap(sort);
+        let vectorKey;
+        let vectorSearch;
+        const regularSort = {};
+        for (const [key, value] of Object.entries(raw)){
+            if (isVectorSearch(value)) {
+                vectorKey = key;
+                vectorSearch = value;
+            } else {
+                regularSort[key] = value;
+            }
+        }
+        if (!vectorKey || !vectorSearch) return undefined;
+        return {
+            vectorKey,
+            vectorSearch,
+            regularSort
+        };
+    }
+    /**
+   * Build a `$vectorSearch` aggregation pipeline stage.
+   * Merges `$where` into `$vectorSearch.filter` for optimal pre-filtering.
+   */ buildVectorSearchStage(entity, meta, key, search, where, limit) {
+        const field = meta.fields[key];
+        if (!field) {
+            throw new TypeError(`Field '${key}' not found in entity '${meta.name}'`);
+        }
+        const colName = this.resolveColumnName(key, field);
+        // Resolve index name from @Index metadata, or fall back to convention
+        const indexMeta = meta.indexes?.find((idx)=>idx.columns.includes(key) && MongoDialect.VECTOR_INDEX_TYPES.has(idx.type));
+        const indexName = indexMeta?.name ?? `${colName}_index`;
+        const stage = {
+            index: indexName,
+            path: colName,
+            queryVector: [
+                ...search.$vector
+            ],
+            numCandidates: limit * 10,
+            limit
+        };
+        // Pre-filter: merge $where into $vectorSearch.filter
+        if (where) {
+            const filter = this.where(entity, where);
+            if (hasKeys(filter)) {
+                stage['filter'] = filter;
+            }
+        }
+        return {
+            $vectorSearch: stage
+        };
+    }
+}
+
+class MongoSchemaGenerator extends AbstractDialect {
+    constructor(namingStrategy, defaultForeignKeyAction){
+        super(MongoDialect.defaultDialectFeatures, {
+            namingStrategy
+        }), this.defaultForeignKeyAction = defaultForeignKeyAction, this.dialectName = 'mongodb', this.insertIdStrategy = 'last';
+    }
+    generateCreateTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        const indexes = [];
+        for (const key of getKeys(meta.fields)){
+            const field = meta.fields[key];
+            if (field?.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                indexes.push({
+                    name: indexName,
+                    columns: [
+                        columnName
+                    ],
+                    unique: !!field.unique
+                });
+            }
+        }
+        return JSON.stringify({
+            action: 'createCollection',
+            name: collectionName,
+            indexes
+        });
+    }
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        return JSON.stringify({
+            action: 'dropCollection',
+            name: collectionName
+        });
+    }
+    generateAlterTable(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        return statements;
+    }
+    generateAlterTableDown(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateDropIndex(diff.tableName, index.name));
+            }
+        }
+        return statements;
+    }
+    generateCreateIndex(tableName, index) {
+        const key = {};
+        for (const col of index.columns){
+            key[col] = 1;
+        }
+        return JSON.stringify({
+            action: 'createIndex',
+            collection: tableName,
+            name: index.name,
+            key,
+            options: {
+                unique: index.unique,
+                name: index.name
+            }
+        });
+    }
+    generateDropIndex(tableName, indexName) {
+        return JSON.stringify({
+            action: 'dropIndex',
+            collection: tableName,
+            name: indexName
+        });
+    }
+    getSqlType(fieldOptions, fieldType) {
+        return '';
+    }
+    getBooleanType() {
+        return '';
+    }
+    generateColumnDefinitions() {
+        return [];
+    }
+    generateColumnDefinition() {
+        return '';
+    }
+    generateColumnDefinitionFromSchema() {
+        return '';
+    }
+    generateTableConstraints() {
+        return [];
+    }
+    generateAlterColumnStatements() {
+        return [];
+    }
+    getTableOptions() {
+        return '';
+    }
+    generateColumnComment() {
+        return '';
+    }
+    formatDefaultValue() {
+        return '';
+    }
+    generateCreateTableFromNode(table) {
+        return JSON.stringify({
+            action: 'createCollection',
+            name: table.name
+        });
+    }
+    generateCreateIndexFromNode(index) {
+        const key = {};
+        for (const col of index.columns){
+            key[col.name] = 1;
+        }
+        return JSON.stringify({
+            action: 'createIndex',
+            collection: index.table.name,
+            name: index.name,
+            key,
+            options: {
+                unique: index.unique,
+                name: index.name
+            }
+        });
+    }
+    generateDropTableFromNode(table) {
+        return JSON.stringify({
+            action: 'dropCollection',
+            name: table.name
+        });
+    }
+    generateCreateTableFromDefinition(table) {
+        return JSON.stringify({
+            action: 'createCollection',
+            name: table.name
+        });
+    }
+    generateDropTableSql(tableName) {
+        return JSON.stringify({
+            action: 'dropCollection',
+            name: tableName
+        });
+    }
+    generateRenameTableSql(oldName, newName) {
+        return JSON.stringify({
+            action: 'renameCollection',
+            from: oldName,
+            to: newName
+        });
+    }
+    generateAddColumnSql() {
+        return '';
+    }
+    generateDropColumnSql() {
+        return '';
+    }
+    generateRenameColumnSql() {
+        return '';
+    }
+    generateAlterColumnSql() {
+        return '';
+    }
+    generateCreateIndexSql(tableName, index) {
+        return this.generateCreateIndex(tableName, index);
+    }
+    generateDropIndexSql(tableName, indexName) {
+        return this.generateDropIndex(tableName, indexName);
+    }
+    generateAddForeignKeySql() {
+        return '';
+    }
+    generateDropForeignKeySql() {
+        return '';
+    }
+    diffSchema(entity, currentTable) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        if (!currentTable) {
+            return {
+                tableName: collectionName,
+                type: 'create'
+            };
+        }
+        const indexesToAdd = [];
+        const existingIndexes = new Set(currentTable.indexes?.map((i)=>i.name) ?? []);
+        for (const key of getKeys(meta.fields)){
+            const field = meta.fields[key];
+            if (field?.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                if (!existingIndexes.has(indexName)) {
+                    indexesToAdd.push({
+                        name: indexName,
+                        columns: [
+                            columnName
+                        ],
+                        unique: !!field.unique
+                    });
+                }
+            }
+        }
+        if (indexesToAdd.length === 0) {
+            return undefined;
+        }
+        return {
+            tableName: collectionName,
+            type: 'alter',
+            indexesToAdd
+        };
+    }
+}
+
+export { MongoSchemaGenerator };
+//# sourceMappingURL=mongoSchemaGenerator-B1IameRz.js.map