@forestadmin-experimental/datasource-cosmos 1.0.0

package/dist/introspection/introspector.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const container_introspector_1 = __importDefault(require("./container-introspector"));
+class Introspector {
+    /**
+     * Introspect all containers in a Cosmos DB database
+     */
+    static async introspect(cosmosClient, databaseName, logger) {
+        logger?.('Info', 'Introspector - Introspect Cosmos DB');
+        return Introspector.introspectAll(cosmosClient, databaseName, logger);
+    }
+    /**
+     * Introspect all containers in the specified database
+     */
+    static async introspectAll(cosmosClient, databaseName, logger) {
+        const results = [];
+        const database = cosmosClient.database(databaseName);
+        // Get all containers in the database
+        const { resources: containers } = await database.containers.readAll().fetchAll();
+        // Filter out system containers if needed
+        const userContainers = containers.filter(container => !container.id.startsWith('_'));
+        logger?.('Info', `Introspector - Found ${userContainers.length} containers in database '${databaseName}'`);
+        // Introspect each container
+        for (const containerInfo of userContainers) {
+            try {
+                const model = await (0, container_introspector_1.default)(cosmosClient, containerInfo.id, // Use container name as collection name
+                databaseName, containerInfo.id, undefined, // Let introspector determine partition key
+                100);
+                results.push(model);
+                logger?.('Info', `Introspector - Successfully introspected container '${containerInfo.id}'`);
+            }
+            catch (error) {
+                logger?.('Warn', `Introspector - Failed to introspect container '${containerInfo.id}': ${error.message}`);
+            }
+        }
+        logger?.('Info', `Introspector - The following containers have been loaded: ${userContainers
+            .map(c => c.id)
+            .join(', ')}`);
+        return results;
+    }
+    /**
+     * Introspect a specific container
+     */
+    static async introspectContainer(cosmosClient, databaseName, containerName, sampleSize, logger) {
+        logger?.('Info', `Introspector - Introspecting container '${containerName}'`);
+        const model = await (0, container_introspector_1.default)(cosmosClient, containerName, databaseName, containerName, undefined, sampleSize || 100);
+        logger?.('Info', `Introspector - Successfully introspected container '${containerName}'`);
+        return model;
+    }
+}
+exports.default = Introspector;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/model-builder/model.d.ts

@@ -0,0 +1,79 @@
+import { Container, CosmosClient, SqlQuerySpec } from '@azure/cosmos';
+import { RecordData } from '@forestadmin/datasource-toolkit';
+import { OverrideTypeConverter } from '../introspection/builder';
+export interface CosmosSchema {
+    [key: string]: {
+        type: string;
+        nullable?: boolean;
+        indexed?: boolean;
+    };
+}
+export default class ModelCosmos {
+    name: string;
+    /**
+     * The Cosmos DB database name
+     */
+    private databaseName;
+    /**
+     * The Cosmos DB container name
+     */
+    private containerName;
+    /**
+     * The partition key path for this container
+     */
+    private partitionKeyPath;
+    /**
+     * Schema definition inferred from sample documents
+     */
+    private schema;
+    /**
+     * Cosmos DB client instance
+     */
+    private cosmosClient;
+    /**
+     * Container reference for direct operations
+     */
+    private container;
+    overrideTypeConverter?: OverrideTypeConverter;
+    enableCount?: boolean;
+    constructor(cosmosClient: CosmosClient, name: string, databaseName: string, containerName: string, partitionKeyPath: string, schema: CosmosSchema, overrideTypeConverter?: OverrideTypeConverter, enableCount?: boolean);
+    create(data: RecordData[]): Promise<RecordData[]>;
+    update(ids: string[], patch: RecordData): Promise<void>;
+    delete(ids: string[]): Promise<void>;
+    query(querySpec: SqlQuerySpec, offset?: number, limit?: number): Promise<RecordData[]>;
+    aggregateQuery(querySpec: SqlQuerySpec): Promise<RecordData[]>;
+    count(querySpec?: SqlQuerySpec): Promise<number>;
+    /**
+     * Get items by their IDs (requires scanning as we don't have partition keys)
+     */
+    private getItemsByIds;
+    /**
+     * Extract the partition key value from an item
+     */
+    private getPartitionKeyValue;
+    /**
+     * Generate a unique ID for new items
+     */
+    private generateId;
+    /**
+     * Return all fields from schema
+     */
+    getAttributes(): CosmosSchema;
+    /**
+     * Get container reference for advanced operations
+     */
+    getContainer(): Container;
+    /**
+     * Get partition key path
+     */
+    getPartitionKeyPath(): string;
+    /**
+     * Get database name
+     */
+    getDatabaseName(): string;
+    /**
+     * Get container name
+     */
+    getContainerName(): string;
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/model-builder/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/model-builder/model.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAkB,YAAY,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;CACH;AAED,MAAM,CAAC,OAAO,OAAO,WAAW;IACvB,IAAI,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,OAAO,CAAC,YAAY,CAAS;IAE7B;;OAEG;IACH,OAAO,CAAC,aAAa,CAAS;IAE9B;;OAEG;IACH,OAAO,CAAC,gBAAgB,CAAS;IAEjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAe;IAE7B;;OAEG;IACH,OAAO,CAAC,YAAY,CAAe;IAEnC;;OAEG;IACH,OAAO,CAAC,SAAS,CAAY;IAEtB,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAE9C,WAAW,CAAC,EAAE,OAAO,CAAC;gBAG3B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,YAAY,EACpB,qBAAqB,CAAC,EAAE,qBAAqB,EAC7C,WAAW,CAAC,EAAE,OAAO;IAcV,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IA4BjD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBvD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAapC,KAAK,CAChB,SAAS,EAAE,YAAY,EACvB,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,UAAU,EAAE,CAAC;IAsBX,cAAc,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAM9D,KAAK,CAAC,SAAS,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAmB7D;;OAEG;YACW,aAAa;IAgB3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACI,aAAa,IAAI,YAAY;IAIpC;;OAEG;IACI,YAAY,IAAI,SAAS;IAIhC;;OAEG;IACI,mBAAmB,IAAI,MAAM;IAIpC;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,gBAAgB,IAAI,MAAM;CAGlC"}

package/dist/model-builder/model.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serializer_1 = __importDefault(require("../utils/serializer"));
+class ModelCosmos {
+    constructor(cosmosClient, name, databaseName, containerName, partitionKeyPath, schema, overrideTypeConverter, enableCount) {
+        this.name = name;
+        this.databaseName = databaseName;
+        this.containerName = containerName;
+        this.partitionKeyPath = partitionKeyPath;
+        this.schema = schema;
+        this.overrideTypeConverter = overrideTypeConverter;
+        this.enableCount = enableCount;
+        this.cosmosClient = cosmosClient;
+        this.container = this.cosmosClient.database(databaseName).container(containerName);
+    }
+    async create(data) {
+        const createdRecords = [];
+        // Add timestamps if schema includes them
+        if (this.schema.createdAt) {
+            data.forEach(newRecord => {
+                newRecord.createdAt = new Date().toISOString();
+            });
+        }
+        // Cosmos DB doesn't have a native bulk create, so we'll create items individually
+        // In production, you might want to use stored procedures or batch operations
+        // eslint-disable-next-line no-restricted-syntax
+        for (const record of data) {
+            // Ensure the record has an id field (required by Cosmos DB)
+            const itemToCreate = {
+                id: record.id || this.generateId(),
+                ...record,
+            };
+            // eslint-disable-next-line no-await-in-loop
+            const { resource } = await this.container.items.create(itemToCreate);
+            createdRecords.push(serializer_1.default.serialize(resource));
+        }
+        return createdRecords;
+    }
+    async update(ids, patch) {
+        // Cosmos DB requires both id and partition key for updates
+        // We need to fetch the items first to get their partition keys
+        const itemsToUpdate = await this.getItemsByIds(ids);
+        // eslint-disable-next-line no-restricted-syntax
+        for (const item of itemsToUpdate) {
+            const partitionKeyValue = this.getPartitionKeyValue(item);
+            // Merge the patch with the existing item
+            const updatedItem = {
+                ...item,
+                ...patch,
+            };
+            // eslint-disable-next-line no-await-in-loop
+            await this.container.item(item.id, partitionKeyValue).replace(updatedItem);
+        }
+    }
+    async delete(ids) {
+        // Similar to update, we need partition keys for deletion
+        const itemsToDelete = await this.getItemsByIds(ids);
+        // eslint-disable-next-line no-restricted-syntax
+        for (const item of itemsToDelete) {
+            const partitionKeyValue = this.getPartitionKeyValue(item);
+            // eslint-disable-next-line no-await-in-loop
+            await this.container.item(item.id, partitionKeyValue).delete();
+        }
+    }
+    async query(querySpec, offset, limit) {
+        const options = {
+            maxItemCount: limit,
+        };
+        const { resources } = await this.container.items.query(querySpec, options).fetchAll();
+        // Apply offset and limit (Cosmos DB doesn't have native OFFSET)
+        let results = resources;
+        if (offset) {
+            results = results.slice(offset);
+        }
+        if (limit && offset) {
+            // If we already sliced with offset, limit the remaining results
+            results = results.slice(0, limit);
+        }
+        return results.map(item => serializer_1.default.serialize(item));
+    }
+    async aggregateQuery(querySpec) {
+        const { resources } = await this.container.items.query(querySpec).fetchAll();
+        return resources.map(item => serializer_1.default.serialize(item));
+    }
+    async count(querySpec) {
+        if (!querySpec) {
+            // Simple count without filters
+            const countQuery = {
+                query: 'SELECT VALUE COUNT(1) FROM c',
+            };
+            const { resources } = await this.container.items.query(countQuery).fetchAll();
+            return resources[0] || 0;
+        }
+        // Count with filters - we need to modify the query to use COUNT
+        const { resources } = await this.container.items.query(querySpec).fetchAll();
+        return resources.length;
+    }
+    // INTERNAL HELPER METHODS
+    /**
+     * Get items by their IDs (requires scanning as we don't have partition keys)
+     */
+    async getItemsByIds(ids) {
+        const querySpec = {
+            query: 'SELECT * FROM c WHERE ARRAY_CONTAINS(@ids, c.id)',
+            parameters: [
+                {
+                    name: '@ids',
+                    value: ids,
+                },
+            ],
+        };
+        const { resources } = await this.container.items.query(querySpec).fetchAll();
+        return resources;
+    }
+    /**
+     * Extract the partition key value from an item
+     */
+    getPartitionKeyValue(item) {
+        // Remove leading slash from partition key path
+        const keyPath = this.partitionKeyPath.replace(/^\//, '');
+        // Handle nested paths (e.g., "/address/city")
+        const keys = keyPath.split('/');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let value = item;
+        for (const key of keys) {
+            if (value && typeof value === 'object') {
+                value = value[key];
+            }
+            else {
+                break;
+            }
+        }
+        return value;
+    }
+    /**
+     * Generate a unique ID for new items
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Return all fields from schema
+     */
+    getAttributes() {
+        return this.schema;
+    }
+    /**
+     * Get container reference for advanced operations
+     */
+    getContainer() {
+        return this.container;
+    }
+    /**
+     * Get partition key path
+     */
+    getPartitionKeyPath() {
+        return this.partitionKeyPath;
+    }
+    /**
+     * Get database name
+     */
+    getDatabaseName() {
+        return this.databaseName;
+    }
+    /**
+     * Get container name
+     */
+    getContainerName() {
+        return this.containerName;
+    }
+}
+exports.default = ModelCosmos;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/aggregation-converter.d.ts

@@ -0,0 +1,30 @@
+import { SqlQuerySpec } from '@azure/cosmos';
+import { AggregateResult, Aggregation, AggregationOperation, ConditionTree } from '@forestadmin/datasource-toolkit';
+export default class AggregationConverter {
+    private static AGGREGATION_OPERATION;
+    /**
+     * Build SQL aggregation query for Cosmos DB
+     */
+    static buildAggregationQuery(aggregation: Aggregation, conditionTree?: ConditionTree, limit?: number): SqlQuerySpec;
+    /**
+     * Build SELECT clause for aggregation expression
+     */
+    private static buildAggregateExpression;
+    /**
+     * Build aggregation query with grouping
+     */
+    private static buildGroupedAggregationQuery;
+    /**
+     * Build date grouping expression
+     */
+    private static buildDateGroupExpression;
+    /**
+     * Process raw aggregation results into Forest Admin format
+     */
+    static processAggregationResults(rawResults: any[], aggregation: Aggregation): AggregateResult[];
+    /**
+     * Build a simpler aggregation query for single-group scenarios
+     */
+    static buildSimpleAggregationQuery(operation: AggregationOperation, field: string | null, groupByField: string | null, conditionTree?: ConditionTree, limit?: number): SqlQuerySpec;
+}
+//# sourceMappingURL=aggregation-converter.d.ts.map

package/dist/utils/aggregation-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-converter.d.ts","sourceRoot":"","sources":["../../src/utils/aggregation-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,aAAa,EAEd,MAAM,iCAAiC,CAAC;AAKzC,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAMlC;IAEF;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAC1B,WAAW,EAAE,WAAW,EACxB,aAAa,CAAC,EAAE,aAAa,EAC7B,KAAK,CAAC,EAAE,MAAM,GACb,YAAY;IAiBf;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAYvC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,4BAA4B;IA6D3C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAyBvC;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAE9B,UAAU,EAAE,GAAG,EAAE,EACjB,WAAW,EAAE,WAAW,GACvB,eAAe,EAAE;IAkCpB;;OAEG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAS,EAAE,oBAAoB,EAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,aAAa,CAAC,EAAE,aAAa,EAC7B,KAAK,CAAC,EAAE,MAAM,GACb,YAAY;CAoChB"}

package/dist/utils/aggregation-converter.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const query_converter_1 = __importDefault(require("./query-converter"));
+const serializer_1 = __importDefault(require("./serializer"));
+class AggregationConverter {
+    /**
+     * Build SQL aggregation query for Cosmos DB
+     */
+    static buildAggregationQuery(aggregation, conditionTree, limit) {
+        const queryConverter = new query_converter_1.default();
+        const { where, parameters } = queryConverter.getWhereClause(conditionTree);
+        const whereFragment = where ? `WHERE ${where}` : '';
+        // Handle simple aggregation without grouping
+        if (!aggregation.groups || aggregation.groups.length === 0) {
+            const selectClause = this.buildAggregateExpression(aggregation);
+            const query = `SELECT ${selectClause} as value FROM c ${whereFragment}`;
+            return { query, parameters };
+        }
+        // Handle aggregation with grouping
+        return this.buildGroupedAggregationQuery(aggregation, whereFragment, parameters, limit);
+    }
+    /**
+     * Build SELECT clause for aggregation expression
+     */
+    static buildAggregateExpression(aggregation) {
+        if (!aggregation.field) {
+            // COUNT(*) case
+            return 'COUNT(1)';
+        }
+        const operation = this.AGGREGATION_OPERATION[aggregation.operation];
+        const fieldPath = `c.${aggregation.field}`;
+        return `${operation}(${fieldPath})`;
+    }
+    /**
+     * Build aggregation query with grouping
+     */
+    static buildGroupedAggregationQuery(aggregation, whereFragment, parameters, limit) {
+        const groups = aggregation.groups || [];
+        // Build the aggregate expression
+        const aggregateExpr = this.buildAggregateExpression(aggregation);
+        // Build the full query
+        // Note: Cosmos DB doesn't support GROUP BY directly in SQL API
+        // We need to use a different approach with subqueries or application-level grouping
+        // For now, we'll use VALUE syntax with DISTINCT for simple grouping
+        if (groups.length === 1 && !groups[0].operation) {
+            // Simple single field grouping
+            const groupField = `c.${groups[0].field}`;
+            // For Count operation without field, we need a different approach
+            if (aggregation.operation === 'Count' && !aggregation.field) {
+                const query = `
+          SELECT ${groupField} as groupKey, COUNT(1) as value
+          FROM c
+          ${whereFragment}
+          GROUP BY ${groupField}
+          ORDER BY ${groupField}
+          ${limit ? `OFFSET 0 LIMIT ${limit}` : ''}
+        `
+                    .trim()
+                    .replace(/\s+/g, ' ');
+                return { query, parameters };
+            }
+            // For other aggregations
+            const query = `
+        SELECT ${groupField} as groupKey, ${aggregateExpr} as value
+        FROM c
+        ${whereFragment}
+        GROUP BY ${groupField}
+        ORDER BY ${groupField}
+        ${limit ? `OFFSET 0 LIMIT ${limit}` : ''}
+      `
+                .trim()
+                .replace(/\s+/g, ' ');
+            return { query, parameters };
+        }
+        // Multiple groups or date operations - more complex, needs special handling
+        // For now, throw an error as this requires more complex implementation
+        const errorMessage = 'Complex grouping with multiple fields or date operations requires ' +
+            'application-level processing. Please implement this using the raw query ' +
+            'results and post-processing.';
+        throw new Error(errorMessage);
+    }
+    /**
+     * Build date grouping expression
+     */
+    static buildDateGroupExpression(field, operation, alias) {
+        const fieldPath = `c.${field}`;
+        switch (operation) {
+            case 'Year':
+                return `DateTimeYear(${fieldPath}) as ${alias}`;
+            case 'Month':
+                return `CONCAT(DateTimeYear(${fieldPath}), '-', DateTimeMonth(${fieldPath})) as ${alias}`;
+            case 'Week':
+                // Cosmos DB doesn't have built-in week function, we'll approximate
+                return `DateTimeDay(${fieldPath}) as ${alias}`;
+            case 'Day':
+                return (`CONCAT(DateTimeYear(${fieldPath}), '-', DateTimeMonth(${fieldPath}), '-', ` +
+                    `DateTimeDay(${fieldPath})) as ${alias}`);
+            default:
+                throw new Error(`Unsupported date operation: ${operation}`);
+        }
+    }
+    /**
+     * Process raw aggregation results into Forest Admin format
+     */
+    static processAggregationResults(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rawResults, aggregation) {
+        // Handle simple aggregation without grouping
+        if (!aggregation.groups || aggregation.groups.length === 0) {
+            if (rawResults.length === 0) {
+                return [{ value: 0, group: {} }];
+            }
+            return [
+                {
+                    value: serializer_1.default.serializeValue(rawResults[0].value),
+                    group: {},
+                },
+            ];
+        }
+        // Handle grouped aggregation
+        return rawResults.map(result => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const group = {};
+            if (aggregation.groups) {
+                aggregation.groups.forEach((groupDef, index) => {
+                    const groupKey = result.groupKey || result[`group${index}`];
+                    group[groupDef.field] = serializer_1.default.serializeValue(groupKey);
+                });
+            }
+            return {
+                value: serializer_1.default.serializeValue(result.value),
+                group,
+            };
+        });
+    }
+    /**
+     * Build a simpler aggregation query for single-group scenarios
+     */
+    static buildSimpleAggregationQuery(operation, field, groupByField, conditionTree, limit) {
+        const queryConverter = new query_converter_1.default();
+        const { where, parameters } = queryConverter.getWhereClause(conditionTree);
+        const whereFragment = where ? `WHERE ${where}` : '';
+        let selectClause;
+        let groupByClause = '';
+        let orderByClause = '';
+        if (!field) {
+            // COUNT(*) case
+            selectClause = groupByField
+                ? `c.${groupByField} as groupKey, COUNT(1) as value`
+                : 'COUNT(1) as value';
+        }
+        else {
+            const op = this.AGGREGATION_OPERATION[operation];
+            const fieldPath = `c.${field}`;
+            selectClause = groupByField
+                ? `c.${groupByField} as groupKey, ${op}(${fieldPath}) as value`
+                : `${op}(${fieldPath}) as value`;
+        }
+        if (groupByField) {
+            groupByClause = `GROUP BY c.${groupByField}`;
+            orderByClause = `ORDER BY c.${groupByField}`;
+        }
+        const limitClause = limit && groupByField ? `OFFSET 0 LIMIT ${limit}` : '';
+        const queryString = `SELECT ${selectClause} FROM c ${whereFragment} ${groupByClause} ` +
+            `${orderByClause} ${limitClause}`;
+        const query = queryString.trim().replace(/\s+/g, ' ');
+        return { query, parameters };
+    }
+}
+AggregationConverter.AGGREGATION_OPERATION = {
+    Sum: 'SUM',
+    Avg: 'AVG',
+    Count: 'COUNT',
+    Max: 'MAX',
+    Min: 'MIN',
+};
+exports.default = AggregationConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/model-to-collection-schema-converter.d.ts

@@ -0,0 +1,9 @@
+import { CollectionSchema, Logger } from '@forestadmin/datasource-toolkit';
+import ModelCosmos from '../model-builder/model';
+export default class ModelToCollectionSchemaConverter {
+    private static convertAttribute;
+    private static convertAttributes;
+    private static getFieldSchemaOrOverride;
+    static convert(model: ModelCosmos, logger?: Logger): CollectionSchema;
+}
+//# sourceMappingURL=model-to-collection-schema-converter.d.ts.map

package/dist/utils/model-to-collection-schema-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-to-collection-schema-converter.d.ts","sourceRoot":"","sources":["../../src/utils/model-to-collection-schema-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAGhB,MAAM,EACP,MAAM,iCAAiC,CAAC;AAIzC,OAAO,WAA6B,MAAM,wBAAwB,CAAC;AAEnE,MAAM,CAAC,OAAO,OAAO,gCAAgC;IACnD,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAqB/B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoChC,OAAO,CAAC,MAAM,CAAC,wBAAwB;WAgBzB,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,gBAAgB;CAmB7E"}

package/dist/utils/model-to-collection-schema-converter.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_converter_1 = __importDefault(require("./type-converter"));
+class ModelToCollectionSchemaConverter {
+    static convertAttribute(fieldName, fieldSchema) {
+        const cosmosType = fieldSchema.type;
+        const columnType = type_converter_1.default.fromDataType(cosmosType);
+        const filterOperators = type_converter_1.default.operatorsForColumnType(columnType);
+        const isSortable = type_converter_1.default.isSortable(cosmosType);
+        const column = {
+            columnType,
+            filterOperators,
+            type: 'Column',
+            validation: [],
+            isReadOnly: false, // Cosmos DB fields are generally writable
+            isSortable,
+        };
+        return column;
+    }
+    static convertAttributes(modelName, schema, overrideTypeConverter, logger) {
+        const fields = {};
+        Object.entries(schema).forEach(([fieldName, fieldSchema]) => {
+            try {
+                fields[fieldName] = this.getFieldSchemaOrOverride(fieldName, fieldSchema, overrideTypeConverter);
+            }
+            catch (error) {
+                logger?.('Warn', `Skipping column '${modelName}.${fieldName}' (${error.message})`);
+            }
+        });
+        // Add the 'id' field which is required by Cosmos DB
+        const idColumn = {
+            columnType: 'String',
+            type: 'Column',
+            filterOperators: type_converter_1.default.operatorsForId(),
+            validation: [],
+            isReadOnly: false, // Can be set when creating documents
+            isSortable: true,
+            isPrimaryKey: true,
+        };
+        fields.id = idColumn;
+        return fields;
+    }
+    static getFieldSchemaOrOverride(fieldName, fieldSchema, overrideTypeConverter) {
+        const field = ModelToCollectionSchemaConverter.convertAttribute(fieldName, fieldSchema);
+        return overrideTypeConverter
+            ? overrideTypeConverter({
+                fieldName,
+                attribute: fieldSchema,
+                generatedFieldSchema: field,
+            }) || field
+            : field;
+    }
+    static convert(model, logger) {
+        if (!model)
+            throw new Error('Invalid (null) model.');
+        return {
+            actions: {},
+            charts: [],
+            countable: model.enableCount ?? true,
+            fields: {
+                ...this.convertAttributes(model.name, model.getAttributes(), model.overrideTypeConverter, logger),
+            },
+            searchable: false, // Cosmos DB doesn't have built-in full-text search like Elasticsearch
+            segments: [],
+        };
+    }
+}
+exports.default = ModelToCollectionSchemaConverter;
+//# sourceMappingURL=data:application/json;base64,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