@goatlab/fluent-loki 0.8.3 → 0.9.0

package/dist/LokiConnector.js

@@ -17,11 +17,14 @@ class LokiConnector extends fluent_1.BaseConnector {
         this.outputSchema =
             outputSchema || inputSchema;
         this.entity = entity;
-        const dbModels = [];
-        for (const collection of dataSource.collections) {
-            dbModels.push(collection.name);
+        // Use Set for O(1) lookup instead of array
+        const dbModels = new Set();
+        const collections = dataSource.collections;
+        const collectionsLength = collections.length;
+        for (let i = 0; i < collectionsLength; i++) {
+            dbModels.add(collections[i].name);
         }
-        if (!dbModels.includes(entity.name)) {
+        if (!dbModels.has(entity.name)) {
             dataSource.addCollection(entity.name);
         }
         this.dataSource = dataSource;
@@ -54,21 +57,26 @@ class LokiConnector extends fluent_1.BaseConnector {
     }
     async insertMany(data) {
         const validatedData = this.inputSchema.array().parse(data);
-        const insertedElements = [];
-        for (const data of validatedData) {
-            const now = new Date();
-            insertedElements.push({
-                ...data,
-                id: js_utils_1.Ids.uuid(),
+        const dataLength = validatedData.length;
+        const insertedElements = new Array(dataLength);
+        const now = new Date();
+        const nowTime = now.getTime(); // Cache timestamp for reuse
+        for (let i = 0; i < dataLength; i++) {
+            const id = js_utils_1.Ids.uuid();
+            insertedElements[i] = {
+                ...validatedData[i],
+                id,
                 created: now,
                 createdAt: now,
                 updatedAt: now
-            });
+            };
         }
         await this.collection.insert(insertedElements);
-        return this.outputSchema.array().parse(insertedElements.map(d => {
-            return js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        }));
+        const cleanedResults = new Array(dataLength);
+        for (let i = 0; i < dataLength; i++) {
+            cleanedResults[i] = js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(insertedElements[i]));
+        }
+        return this.outputSchema.array().parse(cleanedResults);
     }
     /**
      *
@@ -83,40 +91,51 @@ class LokiConnector extends fluent_1.BaseConnector {
     }
     async findMany(query) {
         const where = this.getLokiWhere(query?.where);
-        const sort = [];
         let baseQuery = this.collection
             .chain()
             .find(where);
-        // Pagination
-        if (query?.paginated) {
-            baseQuery.limit(query.paginated.perPage);
-            baseQuery.offset((query.paginated?.page - 1) * query.paginated.perPage);
-        }
+        // Build sort array if needed - pre-calculate total size
         if (query?.orderBy) {
-            for (const order of query?.orderBy) {
-                const flattenObject = js_utils_1.Objects.flatten(order);
-                for (const attribute of Object.keys(flattenObject)) {
-                    const isDecending = flattenObject[attribute] === 'desc';
-                    sort.push([attribute, isDecending]);
+            let totalSortFields = 0;
+            const orderLength = query.orderBy.length;
+            // First pass: count total fields
+            for (let i = 0; i < orderLength; i++) {
+                const flattenObject = js_utils_1.Objects.flatten(query.orderBy[i]);
+                totalSortFields += Object.keys(flattenObject).length;
+            }
+            // Pre-allocate sort array
+            const sort = new Array(totalSortFields);
+            let sortIndex = 0;
+            // Second pass: populate array
+            for (let i = 0; i < orderLength; i++) {
+                const flattenObject = js_utils_1.Objects.flatten(query.orderBy[i]);
+                const attributes = Object.keys(flattenObject);
+                const attrLength = attributes.length;
+                for (let j = 0; j < attrLength; j++) {
+                    const attribute = attributes[j];
+                    const isDescending = flattenObject[attribute] === 'desc';
+                    sort[sortIndex++] = [attribute, isDescending];
                 }
             }
             baseQuery = baseQuery.compoundsort(sort);
         }
-        // Apply offset and limit after sorting
-        if (query?.offset) {
-            baseQuery = baseQuery.offset(query.offset);
-        }
-        if (query?.limit) {
-            baseQuery = baseQuery.limit(query.limit);
+        // Apply pagination, offset and limit
+        if (query?.paginated) {
+            const offset = (query.paginated.page - 1) * query.paginated.perPage;
+            baseQuery = baseQuery.offset(offset).limit(query.paginated.perPage);
         }
-        else if (!query?.paginated) {
-            // Default limit if no pagination
-            baseQuery = baseQuery.limit(10);
+        else {
+            if (query?.offset) {
+                baseQuery = baseQuery.offset(query.offset);
+            }
+            baseQuery = baseQuery.limit(query?.limit || 10);
         }
         let found = baseQuery.data();
-        found.map(d => {
-            js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        });
+        // Clean data in-place
+        const foundLength = found.length;
+        for (let i = 0; i < foundLength; i++) {
+            js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(found[i]));
+        }
         if (query?.paginated) {
             const paginationInfo = {
                 total: 0,
@@ -139,15 +158,19 @@ class LokiConnector extends fluent_1.BaseConnector {
         }
         // Validate Output against schema
         // Use partial schema to handle objects that may have been replaced with partial data
-        const validatedResults = found.map(item => {
+        // Optimize validation by caching partial schema
+        const partialSchema = this.outputSchema.partial();
+        const validatedResults = new Array(found.length);
+        for (let i = 0; i < found.length; i++) {
+            const item = found[i];
             try {
-                return this.outputSchema.parse(item);
+                validatedResults[i] = this.outputSchema.parse(item);
             }
             catch (e) {
                 // If full validation fails, try partial validation
-                return this.outputSchema.partial().parse(item);
+                validatedResults[i] = partialSchema.parse(item);
             }
-        });
+        }
         return validatedResults;
     }
     /**
@@ -193,11 +216,16 @@ class LokiConnector extends fluent_1.BaseConnector {
      * @param data
      */
     async replaceById(id, data) {
-        let value = await this.collection.findOne({ id });
-        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
-        Object.keys(flatValue).forEach(key => {
-            flatValue[key] = null;
-        });
+        const value = await this.collection.findOne({ id });
+        // Avoid JSON parse/stringify overhead
+        const clonedValue = typeof structuredClone !== 'undefined' ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+        const flatValue = js_utils_1.Objects.flatten(clonedValue);
+        const keys = Object.keys(flatValue);
+        const keysLength = keys.length;
+        const nullValue = null;
+        for (let i = 0; i < keysLength; i++) {
+            flatValue[keys[i]] = nullValue;
+        }
         const nullObject = js_utils_1.Objects.nest(flatValue);
         const newValue = { ...nullObject, ...data };
         delete newValue._id;
@@ -207,7 +235,7 @@ class LokiConnector extends fluent_1.BaseConnector {
         const dataToInsert = this.outputKeys.includes('updated')
             ? {
                 ...data,
-                ...{ updated: new Date() }
+                updated: new Date()
             }
             : data;
         // For replace operations, use partial validation since we're replacing with only provided fields
@@ -220,12 +248,16 @@ class LokiConnector extends fluent_1.BaseConnector {
         };
         // Remove all fields except LokiJS metadata and validated fields
         const lokiMetaFields = ['$loki', 'meta'];
-        const allowedFields = [...lokiMetaFields, 'id', 'created', ...Object.keys(validatedData)];
-        Object.keys(updatedValue).forEach(key => {
-            if (!allowedFields.includes(key)) {
+        const validatedKeys = Object.keys(validatedData);
+        const allowedFields = new Set([...lokiMetaFields, 'id', 'created', ...validatedKeys]);
+        const updatedKeys = Object.keys(updatedValue);
+        const updatedKeysLength = updatedKeys.length;
+        for (let i = 0; i < updatedKeysLength; i++) {
+            const key = updatedKeys[i];
+            if (!allowedFields.has(key)) {
                 delete updatedValue[key];
             }
-        });
+        }
         await this.collection.update(updatedValue);
         const val = await this.collection.findOne({ id });
         // For replace operations, use partial output schema since we only have the replaced fields
@@ -233,61 +265,44 @@ class LokiConnector extends fluent_1.BaseConnector {
         return partialOutputSchema.parse(js_utils_1.Objects.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
     }
     getLokiWhere(where) {
-        /*
-    
-        if (this.relationQuery && this.relationQuery.data) {
-          const ids = this.relationQuery.data.map(
-            d => Ids.objectID(d.id) as unknown as ObjectID
-          )
-    
-          andFilters.push([
-            this.relationQuery.relation.inverseSidePropertyPath,
-            'in',
-            ids
-          ])
-        }
-    
-        if (!andFilters || andFilters.length === 0) {
-          return filters
-        }
-        */
         if (!where || Object.keys(where).length === 0) {
             return {};
         }
         const Filters = {
             where: { $or: [{ $and: [] }] }
         };
-        const orConditions = (0, fluent_1.extractConditions)((where['OR'] || []));
-        const andConditions = (0, fluent_1.extractConditions)((where['AND'] || []));
-        const copy = js_utils_1.Objects.clone(where);
-        if (!!copy['AND']) {
-            delete copy['AND'];
-        }
-        if (!!copy['OR']) {
-            delete copy['OR'];
-        }
-        const rootLevelConditions = (0, fluent_1.extractConditions)([copy]);
-        // Process AND conditions
-        for (const condition of andConditions) {
-            let { element, operator, value } = condition;
-            if (element === 'id') {
-                // element = '_id'
-                /*
-                value = (Array.isArray(value)
-                  ? value.map(v => Ids.objectID(v) as unknown as ObjectID)
-                  : (Ids.objectID(value) as unknown as ObjectID) as unknown as PrimitivesArray | Primitives)
-                  */
-            }
+        // Avoid cloning overhead - use destructuring
+        const { AND, OR, ...rootConditions } = where;
+        const orConditions = (0, fluent_1.extractConditions)((OR || []));
+        const andConditions = (0, fluent_1.extractConditions)((AND || []));
+        const rootLevelConditions = (0, fluent_1.extractConditions)([rootConditions]);
+        // Create operator map for O(1) lookup
+        const simpleOperatorMap = new Map([
+            [fluent_1.LogicOperator.equals, '$eq'],
+            [fluent_1.LogicOperator.isNot, '$neq'],
+            [fluent_1.LogicOperator.greaterThan, '$gt'],
+            [fluent_1.LogicOperator.greaterOrEqualThan, '$gte'],
+            [fluent_1.LogicOperator.lessThan, '$lt'],
+            [fluent_1.LogicOperator.lessOrEqualThan, '$lte'],
+            [fluent_1.LogicOperator.in, '$in'],
+            [fluent_1.LogicOperator.exists, '$exists'],
+            [fluent_1.LogicOperator.notExists, '$exists'],
+            [fluent_1.LogicOperator.regexp, '$regex']
+        ]);
+        // Helper function to process conditions
+        const processCondition = (condition, target) => {
+            const { element, operator, value } = condition;
             // Handle nested properties for LokiJS
             if (element.includes('.')) {
                 const parts = element.split('.');
                 const nestedFilter = {};
                 let current = nestedFilter;
-                for (let i = 0; i < parts.length - 1; i++) {
+                const partsLength = parts.length - 1;
+                for (let i = 0; i < partsLength; i++) {
                     current[parts[i]] = {};
                     current = current[parts[i]];
                 }
-                const lastPart = parts[parts.length - 1];
+                const lastPart = parts[partsLength];
                 switch (operator) {
                     case fluent_1.LogicOperator.equals:
                         current[lastPart] = value;
@@ -323,184 +338,60 @@ class LokiConnector extends fluent_1.BaseConnector {
                         current[lastPart] = { $regex: value };
                         break;
                 }
-                Filters.where.$or[0].$and.push(nestedFilter);
+                target.push(nestedFilter);
             }
             else {
-                switch (operator) {
-                    case fluent_1.LogicOperator.equals:
-                        Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
-                        break;
-                    case fluent_1.LogicOperator.isNot:
-                        Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
-                        break;
-                    case fluent_1.LogicOperator.greaterThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
-                        break;
-                    case fluent_1.LogicOperator.greaterOrEqualThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
-                        break;
-                    case fluent_1.LogicOperator.lessThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
-                        break;
-                    case fluent_1.LogicOperator.lessOrEqualThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
-                        break;
-                    case fluent_1.LogicOperator.in:
-                        Filters.where.$or[0].$and.push({ [element]: { $in: value } });
-                        break;
-                    case fluent_1.LogicOperator.notIn:
-                        Filters.where.$or[0].$and.push({
-                            [element]: { $not: { $in: value } }
-                        });
-                        break;
-                    case fluent_1.LogicOperator.exists:
-                        Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
-                        break;
-                    case fluent_1.LogicOperator.notExists:
-                        Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
-                        break;
-                    case fluent_1.LogicOperator.regexp:
-                        Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
-                        break;
+                // Use map for O(1) operator lookup
+                const lokiOp = simpleOperatorMap.get(operator);
+                if (lokiOp) {
+                    if (operator === fluent_1.LogicOperator.notExists) {
+                        target.push({ [element]: { [lokiOp]: false } });
+                    }
+                    else if (operator === fluent_1.LogicOperator.exists) {
+                        target.push({ [element]: { [lokiOp]: true } });
+                    }
+                    else {
+                        target.push({ [element]: { [lokiOp]: value } });
+                    }
+                }
+                else if (operator === fluent_1.LogicOperator.notIn) {
+                    target.push({ [element]: { $not: { $in: value } } });
                 }
             }
+        };
+        // Process AND conditions
+        const andLength = andConditions.length;
+        for (let i = 0; i < andLength; i++) {
+            processCondition(andConditions[i], Filters.where.$or[0].$and);
         }
-        for (const condition of rootLevelConditions) {
-            let { element, operator, value } = condition;
-            if (element === 'id') {
-                // element = '_id'
-                /*
-                value = (Array.isArray(value)
-                  ? value.map(v => Ids.objectID(v) as unknown as ObjectID)
-                  : (Ids.objectID(value) as unknown as ObjectID) as unknown as PrimitivesArray | Primitives)
-                  */
-            }
-            // Handle nested properties for LokiJS
-            if (element.includes('.')) {
-                const parts = element.split('.');
-                const nestedFilter = {};
-                let current = nestedFilter;
-                for (let i = 0; i < parts.length - 1; i++) {
-                    current[parts[i]] = {};
-                    current = current[parts[i]];
+        // Process root level conditions
+        const rootLength = rootLevelConditions.length;
+        for (let i = 0; i < rootLength; i++) {
+            processCondition(rootLevelConditions[i], Filters.where.$or[0].$and);
+        }
+        // Process OR conditions
+        const orLength = orConditions.length;
+        for (let i = 0; i < orLength; i++) {
+            const condition = orConditions[i];
+            const { element, operator, value } = condition;
+            const orFilter = {};
+            // Reuse operator map for consistency
+            const lokiOp = simpleOperatorMap.get(operator);
+            if (lokiOp) {
+                if (operator === fluent_1.LogicOperator.notExists) {
+                    orFilter[element] = { [lokiOp]: false };
                 }
-                const lastPart = parts[parts.length - 1];
-                switch (operator) {
-                    case fluent_1.LogicOperator.equals:
-                        current[lastPart] = value;
-                        break;
-                    case fluent_1.LogicOperator.isNot:
-                        current[lastPart] = { $ne: value };
-                        break;
-                    case fluent_1.LogicOperator.greaterThan:
-                        current[lastPart] = { $gt: value };
-                        break;
-                    case fluent_1.LogicOperator.greaterOrEqualThan:
-                        current[lastPart] = { $gte: value };
-                        break;
-                    case fluent_1.LogicOperator.lessThan:
-                        current[lastPart] = { $lt: value };
-                        break;
-                    case fluent_1.LogicOperator.lessOrEqualThan:
-                        current[lastPart] = { $lte: value };
-                        break;
-                    case fluent_1.LogicOperator.in:
-                        current[lastPart] = { $in: value };
-                        break;
-                    case fluent_1.LogicOperator.notIn:
-                        current[lastPart] = { $nin: value };
-                        break;
-                    case fluent_1.LogicOperator.exists:
-                        current[lastPart] = { $exists: true };
-                        break;
-                    case fluent_1.LogicOperator.notExists:
-                        current[lastPart] = { $exists: false };
-                        break;
-                    case fluent_1.LogicOperator.regexp:
-                        current[lastPart] = { $regex: value };
-                        break;
+                else if (operator === fluent_1.LogicOperator.exists) {
+                    orFilter[element] = { [lokiOp]: true };
                 }
-                Filters.where.$or[0].$and.push(nestedFilter);
-            }
-            else {
-                switch (operator) {
-                    case fluent_1.LogicOperator.equals:
-                        Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
-                        break;
-                    case fluent_1.LogicOperator.isNot:
-                        Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
-                        break;
-                    case fluent_1.LogicOperator.greaterThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
-                        break;
-                    case fluent_1.LogicOperator.greaterOrEqualThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
-                        break;
-                    case fluent_1.LogicOperator.lessThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
-                        break;
-                    case fluent_1.LogicOperator.lessOrEqualThan:
-                        Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
-                        break;
-                    case fluent_1.LogicOperator.in:
-                        Filters.where.$or[0].$and.push({ [element]: { $in: value } });
-                        break;
-                    case fluent_1.LogicOperator.notIn:
-                        Filters.where.$or[0].$and.push({
-                            [element]: { $not: { $in: value } }
-                        });
-                        break;
-                    case fluent_1.LogicOperator.exists:
-                        Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
-                        break;
-                    case fluent_1.LogicOperator.notExists:
-                        Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
-                        break;
-                    case fluent_1.LogicOperator.regexp:
-                        Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
-                        break;
+                else {
+                    orFilter[element] = { [lokiOp]: value };
                 }
             }
-        }
-        for (const condition of orConditions) {
-            let { element, operator, value } = condition;
-            switch (operator) {
-                case fluent_1.LogicOperator.equals:
-                    Filters.where.$or.push({ [element]: { $eq: value } });
-                    break;
-                case fluent_1.LogicOperator.isNot:
-                    Filters.where.$or.push({ [element]: { $neq: value } });
-                    break;
-                case fluent_1.LogicOperator.greaterThan:
-                    Filters.where.$or.push({ [element]: { $gt: value } });
-                    break;
-                case fluent_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where.$or.push({ [element]: { $gte: value } });
-                    break;
-                case fluent_1.LogicOperator.lessThan:
-                    Filters.where.$or.push({ [element]: { $lt: value } });
-                    break;
-                case fluent_1.LogicOperator.lessOrEqualThan:
-                    Filters.where.$or.push({ [element]: { $lte: value } });
-                    break;
-                case fluent_1.LogicOperator.in:
-                    Filters.where.$or.push({ [element]: { $in: value } });
-                    break;
-                case fluent_1.LogicOperator.notIn:
-                    Filters.where.$or.push({
-                        [element]: { $not: { $in: value } }
-                    });
-                    break;
-                case fluent_1.LogicOperator.exists:
-                    Filters.where.$or.push({ [element]: { $exists: true } });
-                    break;
-                case fluent_1.LogicOperator.notExists:
-                    Filters.where.$or.push({ [element]: { $exists: false } });
-                    break;
-                case fluent_1.LogicOperator.regexp:
-                    Filters.where.$or.push({ [element]: { $regex: value } });
-                    break;
+            else if (operator === fluent_1.LogicOperator.notIn) {
+                orFilter[element] = { $not: { $in: value } };
             }
+            Filters.where.$or.push(orFilter);
         }
         // For simple queries without OR conditions, return a simpler format
         if (Filters.where.$or.length === 1 && Filters.where.$or[0].$and.length === 1) {
@@ -508,23 +399,45 @@ class LokiConnector extends fluent_1.BaseConnector {
             // For nested objects, LokiJS needs { "breed.family": "Angora" } format
             // Check if this is a nested object filter
             const keys = Object.keys(filter);
-            if (keys.length === 1 && typeof filter[keys[0]] === 'object' && !filter[keys[0]].$eq && !filter[keys[0]].$ne && !filter[keys[0]].$gt && !filter[keys[0]].$gte && !filter[keys[0]].$lt && !filter[keys[0]].$lte && !filter[keys[0]].$in && !filter[keys[0]].$nin && !filter[keys[0]].$exists && !filter[keys[0]].$regex) {
-                // This is a nested object filter like { breed: { family: "Angora" } }
-                // Convert to dot notation for LokiJS
-                const result = {};
-                const flattenNestedObject = (obj, prefix = '') => {
-                    for (const key in obj) {
-                        const fullKey = prefix ? `${prefix}.${key}` : key;
-                        if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key]) && !obj[key].$eq && !obj[key].$ne && !obj[key].$gt && !obj[key].$gte && !obj[key].$lt && !obj[key].$lte && !obj[key].$in && !obj[key].$nin && !obj[key].$exists && !obj[key].$regex) {
-                            flattenNestedObject(obj[key], fullKey);
+            if (keys.length === 1) {
+                const firstKey = keys[0];
+                const firstValue = filter[firstKey];
+                if (typeof firstValue === 'object' &&
+                    firstValue !== null &&
+                    !Array.isArray(firstValue) &&
+                    !firstValue.$eq && !firstValue.$ne &&
+                    !firstValue.$gt && !firstValue.$gte &&
+                    !firstValue.$lt && !firstValue.$lte &&
+                    !firstValue.$in && !firstValue.$nin &&
+                    !firstValue.$exists && !firstValue.$regex) {
+                    // This is a nested object filter like { breed: { family: "Angora" } }
+                    // Convert to dot notation for LokiJS
+                    const result = {};
+                    const flattenNestedObject = (obj, prefix = '') => {
+                        const objKeys = Object.keys(obj);
+                        const objKeysLength = objKeys.length;
+                        for (let i = 0; i < objKeysLength; i++) {
+                            const key = objKeys[i];
+                            const fullKey = prefix ? `${prefix}.${key}` : key;
+                            const value = obj[key];
+                            if (typeof value === 'object' &&
+                                value !== null &&
+                                !Array.isArray(value) &&
+                                !value.$eq && !value.$ne &&
+                                !value.$gt && !value.$gte &&
+                                !value.$lt && !value.$lte &&
+                                !value.$in && !value.$nin &&
+                                !value.$exists && !value.$regex) {
+                                flattenNestedObject(value, fullKey);
+                            }
+                            else {
+                                result[fullKey] = value;
+                            }
                         }
-                        else {
-                            result[fullKey] = obj[key];
-                        }
-                    }
-                };
-                flattenNestedObject(filter);
-                return result;
+                    };
+                    flattenNestedObject(filter);
+                    return result;
+                }
             }
             return filter;
         }
@@ -545,16 +458,24 @@ class LokiConnector extends fluent_1.BaseConnector {
     loadFirst(query) {
         // Create a clone of the original class
         // to avoid polluting attributes (relatedQuery)
-        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        const detachedClass = this.clone();
         detachedClass.setRelatedQuery({
             entity: this.entity,
             repository: this,
-            query
+            query: {
+                ...query,
+                limit: 1
+            }
         });
         return detachedClass;
     }
     clone() {
-        return new this.constructor();
+        return new this.constructor({
+            entity: this.entity,
+            dataSource: this.dataSource,
+            inputSchema: this.inputSchema,
+            outputSchema: this.outputSchema
+        });
     }
     loadById(id) {
         // Create a new instance to avoid polluting the original one
@@ -582,34 +503,37 @@ class LokiConnector extends fluent_1.BaseConnector {
         // Handle both string and object path formats
         const pathKey = typeof path === 'string' ? path : Object.keys(js_utils_1.Objects.flatten(path))[0];
         const result = [];
-        for (const item of data) {
-            const extracted = js_utils_1.Objects.getFromPath(item, String(pathKey), undefined);
+        const dataArray = data;
+        const dataLength = dataArray.length;
+        for (let i = 0; i < dataLength; i++) {
+            const extracted = js_utils_1.Objects.getFromPath(dataArray[i], String(pathKey), undefined);
             if (typeof extracted.value !== 'undefined') {
                 result.push(extracted.value);
             }
         }
         return result;
     }
+    // Static map for better performance
+    static lokiOperatorMap = new Map([
+        ['=', '$eq'],
+        ['<', '$lt'],
+        ['>', '$gt'],
+        ['<=', '$lte'],
+        ['>=', '$gte'],
+        ['<>', '$ne'],
+        ['!=', '$ne'],
+        ['in', '$in'],
+        ['nin', '$nin'],
+        ['like', '$aeq'],
+        ['regexp', '$regex'],
+        ['startsWith', '$regex|^{{$var}}'],
+        ['endsWith', '$regex|{{$var}}$'],
+        ['contains', '$regex|{{$var}}']
+    ]);
     getLokiOperator(operator) {
-        const lokiOperators = {
-            '=': '$eq',
-            '<': '$lt',
-            '>': '$gt',
-            '<=': '$lte',
-            '>=': '$gte',
-            '<>': '$ne',
-            '!=': '$ne',
-            in: '$in',
-            nin: '$nin',
-            like: '$aeq',
-            regexp: '$regex',
-            startsWith: '$regex|^{{$var}}',
-            endsWith: '$regex|{{$var}}$',
-            contains: '$regex|{{$var}}'
-        };
-        const converted = js_utils_1.Objects.get(() => lokiOperators[operator], undefined);
+        const converted = LokiConnector.lokiOperatorMap.get(operator);
         if (!converted) {
-            throw new Error(`The operator "${operator}" is not supported in Loki `);
+            throw new Error(`The operator "${operator}" is not supported in Loki`);
         }
         return converted;
     }