@loomcore/api 0.0.58 → 0.1.0

package/dist/utils/db.utils.js

@@ -1,323 +0,0 @@
-import { ObjectId } from 'mongodb';
-import _ from 'lodash';
-import { entityUtils } from '@loomcore/common/utils';
-import { stringUtils } from './string.utils.js';
-function getPropertySchema(key, schema) {
-    if (!schema || typeof schema !== 'object')
-        return undefined;
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-        for (const nestedSchema of schema.allOf) {
-            const propSchema = getPropertySchema(key, nestedSchema);
-            if (propSchema)
-                return propSchema;
-        }
-    }
-    if (schema.type === 'object' && schema.properties) {
-        return schema.properties[key];
-    }
-    return undefined;
-}
-export const PROPERTIES_THAT_ARE_NOT_OBJECT_IDS = ['_orgId'];
-function convertObjectIdsToStrings(entity, schema) {
-    if (!entity)
-        return entity;
-    const clone = _.cloneDeep(entity);
-    if (!schema) {
-        if (clone._id && clone._id instanceof ObjectId) {
-            clone._id = clone._id.toString();
-        }
-        return clone;
-    }
-    const processEntity = (obj, subSchema, path = []) => {
-        if (!obj || typeof obj !== 'object')
-            return;
-        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
-            for (const nestedSchema of subSchema.allOf) {
-                processEntity(obj, nestedSchema, path);
-            }
-            return;
-        }
-        if (subSchema.type === 'object' && subSchema.properties) {
-            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
-                if (!propSchema || typeof propSchema !== 'object')
-                    continue;
-                const typedPropSchema = propSchema;
-                const fullPath = [...path, key];
-                if (typedPropSchema.format === 'objectid') {
-                    if (path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
-                        continue;
-                    }
-                    if (obj[key] instanceof ObjectId) {
-                        obj[key] = obj[key].toString();
-                    }
-                }
-                else if (typedPropSchema.type === 'object' && obj[key]) {
-                    processEntity(obj[key], typedPropSchema, fullPath);
-                }
-                else if (typedPropSchema.type === 'array' && Array.isArray(obj[key])) {
-                    const items = typedPropSchema.items;
-                    if (items) {
-                        for (let i = 0; i < obj[key].length; i++) {
-                            if (items.format === 'objectid') {
-                                if (path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
-                                    continue;
-                                }
-                                if (obj[key][i] instanceof ObjectId) {
-                                    obj[key][i] = obj[key][i].toString();
-                                }
-                            }
-                            else if (items.type === 'object') {
-                                processEntity(obj[key][i], items, [...fullPath, i.toString()]);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    };
-    processEntity(clone, schema);
-    return clone;
-}
-function convertStringsToObjectIds(entity, schema) {
-    if (!entity)
-        return entity;
-    const clone = _.cloneDeep(entity);
-    if (clone._id && typeof clone._id === 'string' && entityUtils.isValidObjectId(clone._id)) {
-        clone._id = new ObjectId(clone._id);
-    }
-    const processEntity = (obj, subSchema, path = []) => {
-        if (!obj || typeof obj !== 'object')
-            return obj;
-        if (obj instanceof Date) {
-            return obj;
-        }
-        if (subSchema.allOf && Array.isArray(subSchema.allOf)) {
-            let result = { ...obj };
-            for (const nestedSchema of subSchema.allOf) {
-                result = processEntity(result, nestedSchema, path);
-            }
-            return result;
-        }
-        if (Array.isArray(obj)) {
-            const items = subSchema.items;
-            if (!items)
-                return obj;
-            if (items.format === 'objectid') {
-                if (path.length === 1 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(path[0])) {
-                    return obj;
-                }
-                return obj.map(item => {
-                    if (typeof item === 'string' && entityUtils.isValidObjectId(item)) {
-                        return new ObjectId(item);
-                    }
-                    return item;
-                });
-            }
-            if (items.type === 'object') {
-                return obj.map((item, index) => processEntity(item, items, [...path, index.toString()]));
-            }
-            return obj;
-        }
-        const result = { ...obj };
-        if (subSchema.type === 'object' && subSchema.properties) {
-            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
-                if (!propSchema || typeof propSchema !== 'object' || result[key] === null || result[key] === undefined) {
-                    continue;
-                }
-                const typedPropSchema = propSchema;
-                const fullPath = [...path, key];
-                const value = result[key];
-                const isObjectIdField = typedPropSchema.format === 'objectid';
-                if (isObjectIdField && path.length === 0 && PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)) {
-                    continue;
-                }
-                if (isObjectIdField && typeof value === 'string' && entityUtils.isValidObjectId(value)) {
-                    result[key] = new ObjectId(value);
-                }
-                else if (typedPropSchema.type === 'array' && Array.isArray(value)) {
-                    result[key] = processEntity(value, typedPropSchema, fullPath);
-                }
-                else if (typedPropSchema.type === 'object' && typeof value === 'object' && !Array.isArray(value)) {
-                    result[key] = processEntity(value, typedPropSchema, fullPath);
-                }
-            }
-        }
-        return result;
-    };
-    return processEntity(clone, schema);
-}
-function convertStringToObjectId(value) {
-    if (value instanceof ObjectId) {
-        return value;
-    }
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value === 'string' && entityUtils.isValidObjectId(value)) {
-        try {
-            return new ObjectId(value);
-        }
-        catch (error) {
-            console.warn(`Failed to convert string "${value}" to ObjectId:`, error);
-            return value;
-        }
-    }
-    return value;
-}
-function buildMongoMatchFromQueryOptions(queryOptions, modelSpec) {
-    const filters = queryOptions.filters || {};
-    const schema = modelSpec?.fullSchema;
-    let match = {};
-    console.log('--- Building Mongo Match ---');
-    console.log('Received queryOptions.filters:', JSON.stringify(filters, null, 2));
-    console.log('Received modelSpec:', !!modelSpec);
-    for (const [key, value] of Object.entries(filters)) {
-        if (value) {
-            const propSchema = schema ? getPropertySchema(key, schema) : undefined;
-            if (value.eq !== undefined) {
-                const isObjectIdField = propSchema?.format === 'objectid';
-                const valueToCompare = value.eq;
-                if ((isObjectIdField || (!schema && key.endsWith('Id') && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key)))
-                    && typeof valueToCompare === 'string' && entityUtils.isValidObjectId(valueToCompare)) {
-                    match[key] = new ObjectId(valueToCompare);
-                }
-                else if (typeof valueToCompare === 'string' && !isNaN(Number(valueToCompare))) {
-                    match[key] = Number(valueToCompare);
-                }
-                else {
-                    match[key] = valueToCompare;
-                }
-            }
-            else if (value.in !== undefined && Array.isArray(value.in)) {
-                const isObjectIdArray = propSchema?.type === 'array' && propSchema.items?.format === 'objectid';
-                if (isObjectIdArray || (!schema && (key.endsWith('Id') || key.endsWith('Ids')) && !PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key))) {
-                    const objectIds = value.in
-                        .filter(val => typeof val === 'string' && entityUtils.isValidObjectId(val))
-                        .map(val => new ObjectId(val));
-                    if (objectIds.length > 0) {
-                        match[key] = { $in: objectIds };
-                    }
-                }
-                else {
-                    const convertedValues = value.in.map(val => typeof val === 'string' && !isNaN(Number(val)) ? Number(val) : val);
-                    match[key] = { $in: convertedValues };
-                }
-            }
-            else if (value.gte !== undefined) {
-                match[key] = { $gte: value.gte };
-            }
-            else if (value.lte !== undefined) {
-                match[key] = { $lte: value.lte };
-            }
-            else if (value.gt !== undefined) {
-                match[key] = { $gt: value.gt };
-            }
-            else if (value.lt !== undefined) {
-                match[key] = { $lt: value.lt };
-            }
-            else if (value.contains !== undefined) {
-                match[key] = { $regex: value.contains, $options: 'i' };
-            }
-        }
-    }
-    console.log('Constructed $match object:', JSON.stringify(match, null, 2));
-    console.log('--------------------------');
-    return { $match: match };
-}
-function buildSQLWhereClauseFromQueryOptions(queryOptions, columnAliasMap) {
-    const filters = queryOptions.filters || {};
-    let whereClause = '';
-    for (const [key, value] of Object.entries(filters)) {
-        if (value) {
-            const tableAlias = (columnAliasMap && columnAliasMap[key]) || '';
-            whereClause = addKeyValueToWhereClause(whereClause, key, value, tableAlias);
-        }
-    }
-    return whereClause;
-}
-function addKeyValueToWhereClause(whereClause, key, value, tableAlias = '') {
-    let column = tableAlias ? `${tableAlias}.${stringUtils.pascalCase(key)}` : stringUtils.pascalCase(key);
-    let formattedValue = '';
-    let operator = '=';
-    if (value) {
-        if (value.eq !== undefined) {
-            formattedValue = formatValue(value.eq);
-            operator = '=';
-        }
-        else if (value.in !== undefined && Array.isArray(value.in)) {
-            const formattedValues = value.in.map(val => formatValue(val)).join(', ');
-            formattedValue = `(${formattedValues})`;
-            operator = 'IN';
-        }
-        else if (value.gte !== undefined) {
-            formattedValue = formatValue(value.gte);
-            operator = '>=';
-        }
-        else if (value.lte !== undefined) {
-            formattedValue = formatValue(value.lte);
-            operator = '<=';
-        }
-        else if (value.gt !== undefined) {
-            formattedValue = formatValue(value.gt);
-            operator = '>';
-        }
-        else if (value.lt !== undefined) {
-            formattedValue = formatValue(value.lt);
-            operator = '<';
-        }
-        else if (value.contains !== undefined) {
-            column = `LOWER(${column})`;
-            formattedValue = formatValue(value.contains, true).toLowerCase();
-            operator = 'LIKE';
-        }
-    }
-    const condition = `${column} ${operator} ${formattedValue}`;
-    return appendToWhereClause(whereClause, condition);
-}
-function appendToWhereClause(whereClause, condition) {
-    let newWhereClause = whereClause.trim();
-    if (newWhereClause.toUpperCase() === 'WHERE' || newWhereClause === '') {
-        newWhereClause = `WHERE ${condition}`;
-    }
-    else {
-        newWhereClause = `${newWhereClause} AND ${condition}`;
-    }
-    return newWhereClause;
-}
-function formatValue(value, isLikeOperator = false) {
-    if (typeof value === 'string') {
-        if (!isNaN(Number(value))) {
-            return value;
-        }
-        if (value.toLowerCase() === 'true') {
-            return 'TRUE';
-        }
-        if (value.toLowerCase() === 'false') {
-            return 'FALSE';
-        }
-        return isLikeOperator ? `'%${value}%'` : `'${value}'`;
-    }
-    else if (typeof value === 'number') {
-        return value.toString();
-    }
-    else if (typeof value === 'boolean') {
-        return value ? 'TRUE' : 'FALSE';
-    }
-    else if (value instanceof Date) {
-        const dateString = value.toISOString().split('T')[0];
-        return `DATETIME('${dateString}')`;
-    }
-    else {
-        throw new Error('Unsupported value type');
-    }
-}
-export const dbUtils = {
-    buildMongoMatchFromQueryOptions,
-    buildSQLWhereClauseFromQueryOptions,
-    addKeyValueToWhereClause,
-    appendToWhereClause,
-    formatValue,
-    convertStringToObjectId,
-    convertStringsToObjectIds,
-    convertObjectIdsToStrings,
-};