@forestadmin-experimental/datasource-cosmos 1.2.1 → 1.3.3

package/dist/array-collection.d.ts

@@ -0,0 +1,75 @@
+import { CosmosClient } from '@azure/cosmos';
+import { Aggregation, Caller, CollectionSchema, DataSource, Filter, Logger, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import CosmosCollection from './collection';
+/**
+ * ArrayCollection - A virtual collection that exposes array fields from a parent collection
+ * as a separate collection with full CRUD support.
+ *
+ * This allows treating nested arrays (like kycDetails.diligences) as first-class collections
+ * while keeping data stored in the parent document.
+ */
+export default class ArrayCollection extends CosmosCollection {
+    private parentCollection;
+    private arrayFieldPath;
+    private parentIdField;
+    private virtualizedChildFields;
+    constructor(dataSource: DataSource, parentCollection: CosmosCollection, collectionName: string, arrayFieldPath: string, arrayItemSchema: CollectionSchema, logger?: Logger, cosmosClient?: CosmosClient, virtualizedChildFields?: string[]);
+    /**
+     * Set virtualized child fields (fields that have been converted to virtual collections)
+     */
+    setVirtualizedChildFields(fields: string[]): void;
+    /**
+     * Parse composite ID to get parent ID and array index
+     * For nested virtual collections, splits on the LAST ':' to handle multi-level IDs
+     * e.g., "uuid:1:2" becomes parentId="uuid:1", index=2
+     */
+    private parseCompositeId;
+    /**
+     * Create composite ID from parent ID and index
+     */
+    private createCompositeId;
+    /**
+     * Get the array field value from a parent record
+     */
+    private getArrayFromParent;
+    /**
+     * Set the array field value in a parent record
+     */
+    private setArrayInParent;
+    /**
+     * List array items from parent collection
+     */
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    /**
+     * Apply condition tree filtering to items
+     */
+    private applyConditionTree;
+    /**
+     * Check if a record matches a condition
+     */
+    private matchesCondition;
+    /**
+     * Apply sorting to items
+     */
+    private applySorting;
+    /**
+     * Create a new array item
+     */
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    /**
+     * Update array items
+     */
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    /**
+     * Delete array items
+     */
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    /**
+     * Aggregate - Support Count operations for array collections
+     */
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<Array<{
+        value: number;
+        group: Record<string, unknown>;
+    }>>;
+}
+//# sourceMappingURL=array-collection.d.ts.map

package/dist/array-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-collection.d.ts","sourceRoot":"","sources":["../src/array-collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,WAAW,EACX,MAAM,EACN,gBAAgB,EAIhB,UAAU,EACV,MAAM,EACN,MAAM,EACN,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,gBAAgB,MAAM,cAAc,CAAC;AAG5C;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,gBAAgB;IAC3D,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,sBAAsB,CAAc;gBAG1C,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,gBAAgB,EAClC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,gBAAgB,EACjC,MAAM,CAAC,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,YAAY,EAC3B,sBAAsB,CAAC,EAAE,MAAM,EAAE;IA6GnC;;OAEG;IACI,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIxD;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACY,IAAI,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,EAAE,CAAC;IA4GxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAuC1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuExB;;OAEG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACY,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAwDhF;;OAEG;IACY,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CvF;;OAEG;IACY,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDpE;;OAEG;IACY,SAAS,CACtB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CAsBrE"}

package/dist/array-collection.js

@@ -0,0 +1,510 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_1 = __importDefault(require("./collection"));
+const model_1 = __importDefault(require("./model-builder/model"));
+/**
+ * ArrayCollection - A virtual collection that exposes array fields from a parent collection
+ * as a separate collection with full CRUD support.
+ *
+ * This allows treating nested arrays (like kycDetails.diligences) as first-class collections
+ * while keeping data stored in the parent document.
+ */
+class ArrayCollection extends collection_1.default {
+    constructor(dataSource, parentCollection, collectionName, arrayFieldPath, arrayItemSchema, logger, cosmosClient, virtualizedChildFields) {
+        // Get the parent model to extract Cosmos client info
+        const parentModel = parentCollection
+            .internalModel;
+        logger?.('Debug', `ArrayCollection constructor: parentCollection=${parentCollection?.name}, hasInternalModel=${!!parentModel}`);
+        if (!parentModel) {
+            throw new Error(`Parent collection model is required. ParentCollection name: ${parentCollection?.name}`);
+        }
+        // Use provided cosmosClient or get it from parent model
+        const clientToUse = cosmosClient || parentModel.getCosmosClient();
+        logger?.('Debug', `ArrayCollection: clientToUse=${!!clientToUse}`);
+        if (!clientToUse) {
+            throw new Error('CosmosClient is required to create ArrayCollection');
+        }
+        const dbName = parentModel.getDatabaseName();
+        const containerName = parentModel.getContainerName();
+        const partitionKeyPath = parentModel.getPartitionKeyPath();
+        logger?.('Debug', `ArrayCollection: dbName=${dbName}, containerName=${containerName}, ` +
+            `partitionKeyPath=${partitionKeyPath}`);
+        // Create a minimal model for the array collection
+        // This model won't be used for queries since we override all methods
+        const dummyModel = new model_1.default(clientToUse, collectionName, dbName, containerName, // Use same container as parent
+        partitionKeyPath, {});
+        logger?.('Debug', `ArrayCollection: dummyModel created, name=${dummyModel?.name}, isDefined=${!!dummyModel}`);
+        super(dataSource, dummyModel, logger, clientToUse);
+        this.parentCollection = parentCollection;
+        this.arrayFieldPath = arrayFieldPath;
+        this.parentIdField = `${parentCollection.name}Id`;
+        this.virtualizedChildFields = new Set(virtualizedChildFields || []);
+        // Override the collection name
+        Object.defineProperty(this, 'name', {
+            value: collectionName,
+            writable: false,
+        });
+        // Build schema with composite ID and parent reference
+        const newSchema = {
+            ...arrayItemSchema,
+            fields: {
+                id: {
+                    columnType: 'String',
+                    filterOperators: new Set(['Equal', 'NotEqual', 'In', 'NotIn', 'Present', 'Missing']),
+                    isPrimaryKey: true,
+                    isReadOnly: true,
+                    isSortable: false,
+                    type: 'Column',
+                },
+                [this.parentIdField]: {
+                    columnType: 'String',
+                    filterOperators: new Set([
+                        'Equal',
+                        'NotEqual',
+                        'In',
+                        'NotIn',
+                        'Present',
+                        'Missing',
+                        'Like',
+                        'ILike',
+                        'Contains',
+                        'NotContains',
+                    ]),
+                    isReadOnly: false,
+                    isSortable: true,
+                    type: 'Column',
+                },
+                ...arrayItemSchema.fields,
+            },
+        };
+        // Override the read-only schema property
+        Object.defineProperty(this, 'schema', {
+            value: newSchema,
+            writable: false,
+            configurable: true,
+        });
+    }
+    /**
+     * Set virtualized child fields (fields that have been converted to virtual collections)
+     */
+    setVirtualizedChildFields(fields) {
+        this.virtualizedChildFields = new Set(fields);
+    }
+    /**
+     * Parse composite ID to get parent ID and array index
+     * For nested virtual collections, splits on the LAST ':' to handle multi-level IDs
+     * e.g., "uuid:1:2" becomes parentId="uuid:1", index=2
+     */
+    parseCompositeId(compositeId) {
+        const lastColonIndex = compositeId.lastIndexOf(':');
+        if (lastColonIndex === -1) {
+            throw new Error(`Invalid composite ID format: ${compositeId}`);
+        }
+        const parentId = compositeId.substring(0, lastColonIndex);
+        const indexStr = compositeId.substring(lastColonIndex + 1);
+        return { parentId, index: parseInt(indexStr, 10) };
+    }
+    /**
+     * Create composite ID from parent ID and index
+     */
+    createCompositeId(parentId, index) {
+        return `${parentId}:${index}`;
+    }
+    /**
+     * Get the array field value from a parent record
+     */
+    getArrayFromParent(parentRecord) {
+        // First try the flattened field name (e.g., "kycDetails->diligences")
+        // This is how the datasource returns projected fields
+        if (parentRecord[this.arrayFieldPath] !== undefined) {
+            const value = parentRecord[this.arrayFieldPath];
+            return Array.isArray(value) ? value : [];
+        }
+        // Fall back to nested navigation for cases where data is nested
+        const parts = this.arrayFieldPath.split('->');
+        let value = parentRecord;
+        for (const part of parts) {
+            if (value && typeof value === 'object') {
+                value = value[part];
+            }
+            else {
+                return [];
+            }
+        }
+        return Array.isArray(value) ? value : [];
+    }
+    /**
+     * Set the array field value in a parent record
+     */
+    setArrayInParent(parentRecord, newArray) {
+        const parts = this.arrayFieldPath.split('->');
+        const result = { ...parentRecord };
+        let current = result;
+        // Navigate to the parent object containing the array
+        for (let i = 0; i < parts.length - 1; i += 1) {
+            const part = parts[i];
+            if (!current[part]) {
+                current[part] = {};
+            }
+            current[part] = { ...current[part] };
+            current = current[part];
+        }
+        // Set the array
+        current[parts[parts.length - 1]] = newArray;
+        return result;
+    }
+    /**
+     * List array items from parent collection
+     */
+    async list(caller, filter, projection) {
+        // Extract filters
+        const conditionTree = filter?.conditionTree;
+        let parentFilter;
+        let filterByCompositeId;
+        if (conditionTree instanceof datasource_toolkit_1.ConditionTreeLeaf) {
+            if (conditionTree.field === this.parentIdField) {
+                // Filter by parent ID
+                parentFilter = new datasource_toolkit_1.PaginatedFilter({
+                    conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', conditionTree.operator, conditionTree.value),
+                });
+            }
+            else if (conditionTree.field === 'id') {
+                // Filter by composite ID (e.g., "parent-id:0")
+                // Extract the composite IDs to filter
+                if (conditionTree.operator === 'Equal') {
+                    filterByCompositeId = [conditionTree.value];
+                }
+                else if (conditionTree.operator === 'In') {
+                    filterByCompositeId = conditionTree.value;
+                }
+                // Optimize by only fetching the parent IDs we need
+                if (filterByCompositeId) {
+                    const parentIds = filterByCompositeId.map(cid => this.parseCompositeId(cid).parentId);
+                    const uniqueParentIds = Array.from(new Set(parentIds));
+                    if (uniqueParentIds.length === 1) {
+                        parentFilter = new datasource_toolkit_1.PaginatedFilter({
+                            conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', uniqueParentIds[0]),
+                        });
+                    }
+                    else if (uniqueParentIds.length > 1) {
+                        parentFilter = new datasource_toolkit_1.PaginatedFilter({
+                            conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'In', uniqueParentIds),
+                        });
+                    }
+                }
+            }
+        }
+        // Fetch parent records with the array field
+        const parentRecords = await this.parentCollection.list(caller, parentFilter || new datasource_toolkit_1.PaginatedFilter({}), new datasource_toolkit_1.Projection('id', this.arrayFieldPath));
+        // Flatten array items from all parents
+        const arrayItems = [];
+        for (const parentRecord of parentRecords) {
+            const parentId = parentRecord.id;
+            const arrayValues = this.getArrayFromParent(parentRecord);
+            arrayValues.forEach((item, index) => {
+                // Filter out virtualized child fields (if any are configured)
+                // UNLESS they are explicitly requested in the projection
+                const filteredItem = { ...item };
+                if (this.virtualizedChildFields && this.virtualizedChildFields.size > 0) {
+                    // Get list of requested fields from projection
+                    // Projection is array-like, convert to array for checking
+                    const projectionFields = projection ? Array.from(projection) : [];
+                    const hasProjection = projectionFields.length > 0;
+                    for (const field of this.virtualizedChildFields) {
+                        // Only filter out if:
+                        // 1. There IS a projection (not requesting all fields), AND
+                        // 2. The virtualized field is NOT in the projection
+                        const shouldFilter = hasProjection && !projectionFields.includes(field);
+                        if (shouldFilter) {
+                            delete filteredItem[field];
+                        }
+                    }
+                }
+                arrayItems.push({
+                    id: this.createCompositeId(parentId, index),
+                    [this.parentIdField]: parentId,
+                    ...filteredItem,
+                });
+            });
+        }
+        // Apply composite ID filter if present
+        let filteredItems = arrayItems;
+        if (filterByCompositeId) {
+            const idSet = new Set(filterByCompositeId);
+            filteredItems = arrayItems.filter(item => idSet.has(item.id));
+        }
+        else if (conditionTree) {
+            // Apply general field filtering (for non-ID fields)
+            filteredItems = this.applyConditionTree(arrayItems, conditionTree);
+        }
+        // Apply sorting
+        if (filter?.sort && filter.sort.length > 0) {
+            filteredItems = this.applySorting(filteredItems, filter.sort);
+        }
+        // Apply pagination
+        const { limit, skip } = filter?.page || { limit: undefined, skip: undefined };
+        const start = skip || 0;
+        const end = limit ? start + limit : undefined;
+        return filteredItems.slice(start, end);
+    }
+    /**
+     * Apply condition tree filtering to items
+     */
+    applyConditionTree(items, conditionTree) {
+        if (!conditionTree)
+            return items;
+        // Handle ConditionTreeLeaf (single condition)
+        if (conditionTree instanceof datasource_toolkit_1.ConditionTreeLeaf) {
+            const { field, operator, value } = conditionTree;
+            // Skip ID and parentId filters as they're handled separately
+            if (field === 'id' || field === this.parentIdField) {
+                return items;
+            }
+            return items.filter(item => this.matchesCondition(item, field, operator, value));
+        }
+        // Handle ConditionTreeBranch (AND/OR logic)
+        if ('aggregator' in conditionTree && conditionTree.aggregator) {
+            const branch = conditionTree;
+            const { aggregator, conditions } = branch;
+            if (aggregator === 'And') {
+                return items.filter(item => conditions.every(cond => this.applyConditionTree([item], cond).length > 0));
+            }
+            if (aggregator === 'Or') {
+                return items.filter(item => conditions.some(cond => this.applyConditionTree([item], cond).length > 0));
+            }
+        }
+        return items;
+    }
+    /**
+     * Check if a record matches a condition
+     */
+    matchesCondition(record, field, operator, value) {
+        const fieldValue = record[field];
+        switch (operator) {
+            case 'Equal':
+                return fieldValue === value;
+            case 'NotEqual':
+                return fieldValue !== value;
+            case 'In':
+                return Array.isArray(value) && value.includes(fieldValue);
+            case 'NotIn':
+                return Array.isArray(value) && !value.includes(fieldValue);
+            case 'Present':
+                return fieldValue !== null && fieldValue !== undefined;
+            case 'Missing':
+                return fieldValue === null || fieldValue === undefined;
+            case 'LessThan':
+                return fieldValue < value;
+            case 'LessThanOrEqual':
+                return fieldValue <= value;
+            case 'GreaterThan':
+                return fieldValue > value;
+            case 'GreaterThanOrEqual':
+                return fieldValue >= value;
+            case 'Contains':
+                return (typeof fieldValue === 'string' && typeof value === 'string' && fieldValue.includes(value));
+            case 'NotContains':
+                return (typeof fieldValue === 'string' && typeof value === 'string' && !fieldValue.includes(value));
+            case 'StartsWith':
+                return (typeof fieldValue === 'string' &&
+                    typeof value === 'string' &&
+                    fieldValue.startsWith(value));
+            case 'EndsWith':
+                return (typeof fieldValue === 'string' && typeof value === 'string' && fieldValue.endsWith(value));
+            case 'IContains':
+                return (typeof fieldValue === 'string' &&
+                    typeof value === 'string' &&
+                    fieldValue.toLowerCase().includes(value.toLowerCase()));
+            case 'Like':
+            case 'ILike':
+                // Simple wildcard matching (% for any characters, _ for single character)
+                if (typeof fieldValue === 'string' && typeof value === 'string') {
+                    const pattern = value.replace(/%/g, '.*').replace(/_/g, '.');
+                    const regex = new RegExp(`^${pattern}$`, operator === 'ILike' ? 'i' : '');
+                    return regex.test(fieldValue);
+                }
+                return false;
+            default:
+                console.warn(`[ArrayCollection] Unsupported operator: ${operator}`);
+                return true; // Don't filter out if we don't know the operator
+        }
+    }
+    /**
+     * Apply sorting to items
+     */
+    applySorting(items, sort) {
+        return [...items].sort((a, b) => {
+            for (const { field, ascending } of sort) {
+                const aValue = a[field];
+                const bValue = b[field];
+                // Handle null/undefined - skip to next sort criteria if both are null
+                if (aValue == null && bValue == null) {
+                    // Both null, continue to next sort field
+                }
+                else if (aValue == null) {
+                    return ascending ? 1 : -1;
+                }
+                else if (bValue == null) {
+                    return ascending ? -1 : 1;
+                }
+                else {
+                    // Compare values
+                    let comparison = 0;
+                    if (typeof aValue === 'string' && typeof bValue === 'string') {
+                        comparison = aValue.localeCompare(bValue);
+                    }
+                    else if (typeof aValue === 'number' && typeof bValue === 'number') {
+                        comparison = aValue - bValue;
+                    }
+                    else if (aValue instanceof Date && bValue instanceof Date) {
+                        comparison = aValue.getTime() - bValue.getTime();
+                    }
+                    else {
+                        // Fallback: convert to string and compare
+                        comparison = String(aValue).localeCompare(String(bValue));
+                    }
+                    if (comparison !== 0) {
+                        return ascending ? comparison : -comparison;
+                    }
+                }
+            }
+            return 0;
+        });
+    }
+    /**
+     * Create a new array item
+     */
+    async create(caller, data) {
+        const results = [];
+        // Sequential execution required: each array item must be added one at a time to maintain
+        // consistent ordering and prevent race conditions when multiple items target the same parent
+        for (const item of data) {
+            const parentId = item[this.parentIdField];
+            if (!parentId) {
+                throw new Error(`${this.parentIdField} is required to create array items`);
+            }
+            // Remove parent ID and composite ID from the item data using destructuring
+            const { id: unusedItemId, [this.parentIdField]: unusedParentIdValue, ...itemData } = item;
+            void unusedItemId;
+            void unusedParentIdValue;
+            // Fetch the parent record
+            // eslint-disable-next-line no-await-in-loop -- Sequential maintains consistent ordering
+            const parentRecords = await this.parentCollection.list(caller, new datasource_toolkit_1.PaginatedFilter({
+                conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId),
+            }), new datasource_toolkit_1.Projection('id', this.arrayFieldPath));
+            if (parentRecords.length === 0) {
+                throw new Error(`Parent record with id ${parentId} not found`);
+            }
+            const parentRecord = parentRecords[0];
+            const currentArray = this.getArrayFromParent(parentRecord);
+            // Add the new item to the array
+            const newArray = [...currentArray, itemData];
+            const newIndex = currentArray.length;
+            // Update the parent record - sequential to prevent conflicts
+            // eslint-disable-next-line no-await-in-loop -- Sequential prevents data conflicts
+            await this.parentCollection.update(caller, new datasource_toolkit_1.Filter({ conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId) }), { [this.arrayFieldPath]: newArray });
+            results.push({
+                id: this.createCompositeId(parentId, newIndex),
+                [this.parentIdField]: parentId,
+                ...itemData,
+            });
+        }
+        return results;
+    }
+    /**
+     * Update array items
+     */
+    async update(caller, filter, patch) {
+        // List all records matching the filter
+        const records = await this.list(caller, new datasource_toolkit_1.PaginatedFilter(filter), new datasource_toolkit_1.Projection('id'));
+        // Sequential execution required: updating array items must be done one at a time
+        // to prevent conflicts when multiple updates target the same parent document
+        for (const record of records) {
+            const { parentId, index } = this.parseCompositeId(record.id);
+            // Fetch the parent record
+            // eslint-disable-next-line no-await-in-loop -- Sequential prevents data conflicts
+            const parentRecords = await this.parentCollection.list(caller, new datasource_toolkit_1.PaginatedFilter({
+                conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId),
+            }), new datasource_toolkit_1.Projection('id', this.arrayFieldPath));
+            // Skip if parent not found or item doesn't exist
+            if (parentRecords.length > 0) {
+                const parentRecord = parentRecords[0];
+                const array = this.getArrayFromParent(parentRecord);
+                if (array[index]) {
+                    // Update the item at the specified index
+                    const currentItem = typeof array[index] === 'object' && array[index] !== null
+                        ? array[index]
+                        : {};
+                    array[index] = { ...currentItem, ...patch };
+                    // Update the parent record - sequential to prevent conflicts
+                    // eslint-disable-next-line no-await-in-loop -- Sequential prevents data conflicts
+                    await this.parentCollection.update(caller, new datasource_toolkit_1.Filter({ conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId) }), { [this.arrayFieldPath]: array });
+                }
+            }
+        }
+    }
+    /**
+     * Delete array items
+     */
+    async delete(caller, filter) {
+        // List all records matching the filter
+        const records = await this.list(caller, new datasource_toolkit_1.PaginatedFilter(filter), new datasource_toolkit_1.Projection('id'));
+        // Group by parent ID to minimize updates
+        const recordsByParent = new Map();
+        for (const record of records) {
+            const { parentId, index } = this.parseCompositeId(record.id);
+            if (!recordsByParent.has(parentId)) {
+                recordsByParent.set(parentId, []);
+            }
+            recordsByParent.get(parentId)?.push(index);
+        }
+        // Sequential execution required: deleting array items must be done one parent at a time
+        // to prevent conflicts and ensure data consistency
+        for (const [parentId, indices] of recordsByParent) {
+            // Fetch the parent record
+            // eslint-disable-next-line no-await-in-loop -- Sequential prevents data conflicts
+            const parentRecords = await this.parentCollection.list(caller, new datasource_toolkit_1.PaginatedFilter({
+                conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId),
+            }), new datasource_toolkit_1.Projection('id', this.arrayFieldPath));
+            // Skip if parent not found
+            if (parentRecords.length > 0) {
+                const parentRecord = parentRecords[0];
+                const array = this.getArrayFromParent(parentRecord);
+                // Remove items at the specified indices (sort in reverse to avoid index shifting)
+                const sortedIndices = indices.sort((a, b) => b - a);
+                for (const index of sortedIndices) {
+                    array.splice(index, 1);
+                }
+                // Update the parent record - sequential to prevent conflicts
+                // eslint-disable-next-line no-await-in-loop -- Sequential prevents data conflicts
+                await this.parentCollection.update(caller, new datasource_toolkit_1.Filter({ conditionTree: new datasource_toolkit_1.ConditionTreeLeaf('id', 'Equal', parentId) }), { [this.arrayFieldPath]: array });
+            }
+        }
+    }
+    /**
+     * Aggregate - Support Count operations for array collections
+     */
+    async aggregate(caller, filter, aggregation, limit) {
+        void limit; // Unused parameter required by interface
+        // Only support Count operation
+        if (aggregation.operation !== 'Count') {
+            throw new Error(`Aggregation operation '${aggregation.operation}' is not supported for ` +
+                `array collections. Only Count is supported.`);
+        }
+        // Get all records that match the filter
+        const records = await this.list(caller, new datasource_toolkit_1.PaginatedFilter(filter), new datasource_toolkit_1.Projection('id'));
+        // Return count aggregation result
+        return [
+            {
+                value: records.length,
+                group: {},
+            },
+        ];
+    }
+}
+exports.default = ArrayCollection;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-collection.js","sourceRoot":"","sources":["../src/array-collection.ts"],"names":[],"mappings":"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"}

package/dist/collection.d.ts

@@ -5,6 +5,11 @@ export default class CosmosCollection extends BaseCollection {
     protected internalModel: ModelCosmos;
     private queryConverter;
     constructor(datasource: DataSource, model: ModelCosmos, logger: Logger, nativeDriver: CosmosClient);
+    /**
+     * Mark virtualized array fields as non-sortable
+     * This should be called after virtual collections are created from array fields
+     */
+    markVirtualizedFieldsAsNonSortable(virtualizedFieldPaths: string[]): void;
     create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
     list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
     update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;

package/dist/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,eAAe,EACf,WAAW,EACX,cAAc,EACd,MAAM,EACN,UAAU,EACV,MAAM,EACN,MAAM,EACN,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAKhD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,SAAS,CAAC,aAAa,EAAE,WAAW,CAAC;IAErC,OAAO,CAAC,cAAc,CAAiB;gBAGrC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY;IAmBtB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAUjE,IAAI,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,EAAE,CAAC;IA6DlB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC;CAkB9B"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,eAAe,EACf,WAAW,EACX,cAAc,EACd,MAAM,EACN,UAAU,EACV,MAAM,EACN,MAAM,EACN,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAKhD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,SAAS,CAAC,aAAa,EAAE,WAAW,CAAC;IAErC,OAAO,CAAC,cAAc,CAAiB;gBAGrC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY;IAmB5B;;;OAGG;IACI,kCAAkC,CAAC,qBAAqB,EAAE,MAAM,EAAE,GAAG,IAAI;IAgB1E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAUjE,IAAI,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,EAAE,CAAC;IA8DlB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC;CAkB9B"}