uql-orm 0.9.4 → 0.10.1

package/dist/browser/mongoSchemaGenerator-BT2_u1wI.js

@@ -1,735 +0,0 @@
-import { getMeta } from '../entity/index.js';
-import { ObjectId } from 'mongodb';
-import { buildQueryWhereAsMap, normalizeScalarFieldSelection, buildSortMap, hasKeys, getRelationRequestSummary, 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, exclude) {
-        const meta = getMeta(entity);
-        if (!select && !exclude) {
-            return {};
-        }
-        const selectedFields = normalizeScalarFieldSelection(meta, select, exclude);
-        return selectedFields.reduce((acc, key)=>{
-            acc[key] = 1;
-            return acc;
-        }, {});
-    }
-    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, relationSummary) {
-        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 = (relationSummary ?? getRelationRequestSummary(meta, q.$populate)).joinableKeys;
-        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, _options) {
-        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, _options) {
-        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, _options) {
-        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-BT2_u1wI.js.map