@forestadmin-experimental/datasource-cosmos 1.0.0

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

@@ -0,0 +1,38 @@
+import { SqlParameter, SqlQuerySpec } from '@azure/cosmos';
+import { ConditionTree, Sort } from '@forestadmin/datasource-toolkit';
+export default class QueryConverter {
+    private parameterCounter;
+    private parameters;
+    /**
+     * Reset the converter state for a new query
+     */
+    private reset;
+    /**
+     * Add a parameter and return its name
+     */
+    private addParameter;
+    /**
+     * Convert a single condition to SQL WHERE clause fragment
+     */
+    private makeWhereClause;
+    /**
+     * Recursively convert a condition tree to SQL WHERE clause
+     */
+    private getWhereClauseFromConditionTree;
+    /**
+     * Convert condition tree to a complete SQL query spec
+     */
+    getSqlQuerySpec(conditionTree?: ConditionTree, sort?: Sort, projection?: string[]): SqlQuerySpec;
+    /**
+     * Convert sort to ORDER BY clause
+     */
+    getOrderByClause(sort?: Sort): string;
+    /**
+     * Get WHERE clause only (for use in subqueries or COUNT operations)
+     */
+    getWhereClause(conditionTree?: ConditionTree): {
+        where: string;
+        parameters: SqlParameter[];
+    };
+}
+//# sourceMappingURL=query-converter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-converter.d.ts","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,aAAa,EAIb,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,UAAU,CAAsB;IAExC;;OAEG;IACH,OAAO,CAAC,KAAK;IAKb;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACH,OAAO,CAAC,eAAe;IA0HvB;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAyCvC;;OAEG;IACI,eAAe,CACpB,aAAa,CAAC,EAAE,aAAa,EAC7B,IAAI,CAAC,EAAE,IAAI,EACX,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,YAAY;IA2Bf;;OAEG;IACI,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;IAe5C;;OAEG;IACI,cAAc,CAAC,aAAa,CAAC,EAAE,aAAa,GAAG;QACpD,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,YAAY,EAAE,CAAC;KAC5B;CAMF"}

package/dist/utils/query-converter.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class QueryConverter {
+    constructor() {
+        this.parameterCounter = 0;
+        this.parameters = [];
+    }
+    /**
+     * Reset the converter state for a new query
+     */
+    reset() {
+        this.parameterCounter = 0;
+        this.parameters = [];
+    }
+    /**
+     * Add a parameter and return its name
+     */
+    addParameter(value) {
+        const paramName = `@param${this.parameterCounter}`;
+        this.parameterCounter += 1;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.parameters.push({ name: paramName, value: value });
+        return paramName;
+    }
+    /**
+     * Convert a single condition to SQL WHERE clause fragment
+     */
+    makeWhereClause(field, operator, value) {
+        // Use 'c' as the root alias for Cosmos DB queries
+        const fieldPath = field === 'id' ? 'c.id' : `c.${field}`;
+        switch (operator) {
+            // Presence
+            case 'Present':
+                return `IS_DEFINED(${fieldPath}) AND ${fieldPath} != null`;
+            case 'Missing':
+                return `(NOT IS_DEFINED(${fieldPath}) OR ${fieldPath} = null)`;
+            // Equality
+            case 'Equal':
+                if (value === null || value === undefined) {
+                    return `(NOT IS_DEFINED(${fieldPath}) OR ${fieldPath} = null)`;
+                }
+                return `${fieldPath} = ${this.addParameter(value)}`;
+            case 'NotEqual':
+                if (value === null || value === undefined) {
+                    return `IS_DEFINED(${fieldPath}) AND ${fieldPath} != null`;
+                }
+                return `${fieldPath} != ${this.addParameter(value)}`;
+            case 'In': {
+                const values = Array.isArray(value) ? value : [value];
+                if (values.length === 0)
+                    return '1 = 0'; // Always false
+                if (values.some(v => v === null || v === undefined)) {
+                    const nonNullValues = values.filter(v => v !== null && v !== undefined);
+                    if (nonNullValues.length === 0) {
+                        return `(NOT IS_DEFINED(${fieldPath}) OR ${fieldPath} = null)`;
+                    }
+                    const paramName = this.addParameter(nonNullValues);
+                    return (`(ARRAY_CONTAINS(${paramName}, ${fieldPath}) OR ` +
+                        `NOT IS_DEFINED(${fieldPath}) OR ${fieldPath} = null)`);
+                }
+                const paramName = this.addParameter(values);
+                return `ARRAY_CONTAINS(${paramName}, ${fieldPath})`;
+            }
+            case 'NotIn': {
+                const values = Array.isArray(value) ? value : [value];
+                if (values.length === 0)
+                    return '1 = 1'; // Always true
+                const paramName = this.addParameter(values);
+                return `NOT ARRAY_CONTAINS(${paramName}, ${fieldPath})`;
+            }
+            // Ranges
+            case 'LessThan':
+                return `${fieldPath} < ${this.addParameter(value)}`;
+            case 'GreaterThan':
+                return `${fieldPath} > ${this.addParameter(value)}`;
+            // Strings
+            case 'Like':
+            // fallthrough
+            case 'ILike': {
+                const pattern = String(value).replace(/^%/, '').replace(/%$/, '');
+                const paramName = this.addParameter(pattern);
+                if (operator === 'ILike') {
+                    return `CONTAINS(LOWER(${fieldPath}), LOWER(${paramName}))`;
+                }
+                return `CONTAINS(${fieldPath}, ${paramName})`;
+            }
+            case 'Contains': {
+                const paramName = this.addParameter(value);
+                return `CONTAINS(${fieldPath}, ${paramName})`;
+            }
+            case 'NotContains': {
+                const paramName = this.addParameter(value);
+                return `NOT CONTAINS(${fieldPath}, ${paramName})`;
+            }
+            case 'StartsWith': {
+                const paramName = this.addParameter(value);
+                return `STARTSWITH(${fieldPath}, ${paramName})`;
+            }
+            case 'EndsWith': {
+                const paramName = this.addParameter(value);
+                return `ENDSWITH(${fieldPath}, ${paramName})`;
+            }
+            // Array operations
+            case 'IncludesAll': {
+                const values = Array.isArray(value) ? value : [value];
+                const conditions = values.map(v => {
+                    const paramName = this.addParameter(v);
+                    return `ARRAY_CONTAINS(${fieldPath}, ${paramName})`;
+                });
+                return `(${conditions.join(' AND ')})`;
+            }
+            default:
+                throw new Error(`Unsupported operator: "${operator}".`);
+        }
+    }
+    /**
+     * Recursively convert a condition tree to SQL WHERE clause
+     */
+    getWhereClauseFromConditionTree(conditionTree) {
+        if (!conditionTree)
+            return '';
+        if (conditionTree.aggregator !== undefined) {
+            const { aggregator, conditions } = conditionTree;
+            if (aggregator === null) {
+                throw new Error('Invalid (null) aggregator.');
+            }
+            if (!Array.isArray(conditions) || conditions.length === 0) {
+                throw new Error('Conditions must be a non-empty array.');
+            }
+            const operator = aggregator === 'And' ? ' AND ' : ' OR ';
+            const clauses = conditions
+                .map(condition => this.getWhereClauseFromConditionTree(condition))
+                .filter(clause => clause !== '');
+            if (clauses.length === 0)
+                return '';
+            if (clauses.length === 1)
+                return clauses[0];
+            return `(${clauses.join(operator)})`;
+        }
+        if (conditionTree.operator !== undefined) {
+            const { field, operator, value } = conditionTree;
+            // Check for relation fields (not supported yet)
+            const isRelation = field.includes(':');
+            if (isRelation) {
+                throw new Error('Relation ConditionTree not yet supported for Cosmos DB.');
+            }
+            return this.makeWhereClause(field, operator, value);
+        }
+        throw new Error('Invalid ConditionTree.');
+    }
+    /**
+     * Convert condition tree to a complete SQL query spec
+     */
+    getSqlQuerySpec(conditionTree, sort, projection) {
+        // Reset state for new query
+        this.reset();
+        // Build SELECT clause
+        const selectClause = projection && projection.length > 0
+            ? projection.map(field => (field === 'id' ? 'c.id' : `c.${field}`)).join(', ')
+            : 'c';
+        // Build WHERE clause
+        const whereClause = this.getWhereClauseFromConditionTree(conditionTree);
+        const whereFragment = whereClause ? `WHERE ${whereClause}` : '';
+        // Build ORDER BY clause
+        const orderByClause = this.getOrderByClause(sort);
+        const orderByFragment = orderByClause ? `ORDER BY ${orderByClause}` : '';
+        // Combine into full query
+        const query = `SELECT ${selectClause} FROM c ${whereFragment} ${orderByFragment}`.trim();
+        return {
+            query,
+            parameters: this.parameters,
+        };
+    }
+    /**
+     * Convert sort to ORDER BY clause
+     */
+    getOrderByClause(sort) {
+        if (!sort || sort.length === 0)
+            return '';
+        const sortClauses = sort
+            .map(({ field, ascending }) => {
+            const fieldPath = field === 'id' ? 'c.id' : `c.${field}`;
+            const direction = ascending ? 'ASC' : 'DESC';
+            return `${fieldPath} ${direction}`;
+        })
+            .filter(Boolean);
+        return sortClauses.join(', ');
+    }
+    /**
+     * Get WHERE clause only (for use in subqueries or COUNT operations)
+     */
+    getWhereClause(conditionTree) {
+        this.reset();
+        const where = this.getWhereClauseFromConditionTree(conditionTree);
+        return { where, parameters: this.parameters };
+    }
+}
+exports.default = QueryConverter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-converter.js","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"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"}

package/dist/utils/serializer.d.ts

@@ -0,0 +1,6 @@
+import { RecordData } from '@forestadmin/datasource-toolkit';
+export default class Serializer {
+    static serialize(record: RecordData): RecordData;
+    static serializeValue(value: unknown): unknown;
+}
+//# sourceMappingURL=serializer.d.ts.map

package/dist/utils/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/utils/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU;IAUhD,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAY/C"}

package/dist/utils/serializer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Serializer {
+    static serialize(record) {
+        Object.entries(record).forEach(([name, value]) => {
+            if (value instanceof Date)
+                record[name] = this.serializeValue(value);
+            if (Array.isArray(value))
+                this.serializeValue(value); // the change is by references
+            if (value instanceof Object)
+                return this.serialize(record[name]);
+        });
+        return record;
+    }
+    static serializeValue(value) {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (Array.isArray(value)) {
+            value.forEach((v, i) => {
+                // serialize by reference to improve performances by avoiding the copies
+                if (value instanceof Date)
+                    value[i] = v.toISOString();
+            });
+        }
+        return value;
+    }
+}
+exports.default = Serializer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9zZXJpYWxpemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsTUFBcUIsVUFBVTtJQUM3QixNQUFNLENBQUMsU0FBUyxDQUFDLE1BQWtCO1FBQ2pDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRTtZQUMvQyxJQUFJLEtBQUssWUFBWSxJQUFJO2dCQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3JFLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUM7Z0JBQUUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDhCQUE4QjtZQUNwRixJQUFJLEtBQUssWUFBWSxNQUFNO2dCQUFFLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUNuRSxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQWM7UUFDbEMsSUFBSSxLQUFLLFlBQVksSUFBSTtZQUFFLE9BQU8sS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRXRELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3pCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUU7Z0JBQ3JCLHdFQUF3RTtnQkFDeEUsSUFBSSxLQUFLLFlBQVksSUFBSTtvQkFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3hELENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGO0FBdkJELDZCQXVCQyJ9

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

@@ -0,0 +1,43 @@
+import { ColumnType, Operator } from '@forestadmin/datasource-toolkit';
+/**
+ * Cosmos DB doesn't enforce strict types, but we can infer types from sample data
+ * and map them to Forest Admin types
+ */
+export type CosmosDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'null' | 'binary' | 'point';
+export default class TypeConverter {
+    static fromDataType(dataType: CosmosDataType): ColumnType;
+    /**
+     * Map Cosmos DB data types to Forest Admin column types
+     * Since Cosmos DB is schemaless, these types are inferred from sample documents
+     */
+    private static getColumnTypeFromDataType;
+    /**
+     * Infer Cosmos data type from a JavaScript value
+     */
+    static inferTypeFromValue(value: unknown): CosmosDataType;
+    /**
+     * Check if a string is a valid ISO date
+     */
+    private static isDateString;
+    /**
+     * Check if an object is a GeoJSON Point
+     */
+    private static isGeoPoint;
+    /**
+     * All fields in Cosmos DB are sortable (no text analysis like Elasticsearch)
+     */
+    static isSortable(dataType: CosmosDataType): boolean;
+    /**
+     * Get supported operators for a given column type
+     */
+    static operatorsForColumnType(columnType: ColumnType): Set<Operator>;
+    /**
+     * Operators supported for the id field
+     */
+    static operatorsForId(): Set<Operator>;
+    /**
+     * Get the most specific common type from an array of types
+     */
+    static getMostSpecificType(types: CosmosDataType[]): CosmosDataType;
+}
+//# sourceMappingURL=type-converter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-converter.d.ts","sourceRoot":"","sources":["../../src/utils/type-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAkB,MAAM,iCAAiC,CAAC;AAEvF;;;GAGG;AACH,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,MAAM,GACN,QAAQ,GACR,OAAO,GACP,MAAM,GACN,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,CAAC,OAAO,OAAO,aAAa;WAClB,YAAY,CAAC,QAAQ,EAAE,cAAc,GAAG,UAAU;IAIhE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IA8BxC;;OAEG;WACW,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc;IA4BhE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAU3B;;OAEG;IAEH,OAAO,CAAC,MAAM,CAAC,UAAU;IAUzB;;OAEG;WACW,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO;IAK3D;;OAEG;WACW,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,GAAG,CAAC,QAAQ,CAAC;IAiC3E;;OAEG;WACW,cAAc,IAAI,GAAG,CAAC,QAAQ,CAAC;IAI7C;;OAEG;WACW,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,cAAc;CAqB3E"}

package/dist/utils/type-converter.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TypeConverter {
+    static fromDataType(dataType) {
+        return TypeConverter.getColumnTypeFromDataType(dataType);
+    }
+    /**
+     * Map Cosmos DB data types to Forest Admin column types
+     * Since Cosmos DB is schemaless, these types are inferred from sample documents
+     */
+    static getColumnTypeFromDataType(dataType) {
+        switch (dataType) {
+            case 'boolean':
+                return 'Boolean';
+            case 'date':
+                return 'Date';
+            case 'number':
+                return 'Number';
+            case 'string':
+                return 'String';
+            case 'binary':
+                return 'String'; // Base64 encoded strings
+            case 'point':
+                return 'Point'; // GeoJSON point
+            case 'object':
+            case 'array':
+            case 'null':
+                return 'Json';
+            default:
+                throw new Error(`Unsupported data type: "${dataType}"`);
+        }
+    }
+    /**
+     * Infer Cosmos data type from a JavaScript value
+     */
+    static inferTypeFromValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'null';
+        if (typeof value === 'boolean')
+            return 'boolean';
+        if (typeof value === 'number')
+            return 'number';
+        if (typeof value === 'string') {
+            // Try to detect if it's a date string
+            if (this.isDateString(value))
+                return 'date';
+            return 'string';
+        }
+        if (Array.isArray(value))
+            return 'array';
+        if (typeof value === 'object') {
+            // Check for GeoJSON Point
+            if (this.isGeoPoint(value))
+                return 'point';
+            // Check for Date object
+            if (value instanceof Date)
+                return 'date';
+            return 'object';
+        }
+        return 'string'; // Default fallback
+    }
+    /**
+     * Check if a string is a valid ISO date
+     */
+    static isDateString(value) {
+        // Match ISO 8601 date format
+        const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+        if (!isoDateRegex.test(value))
+            return false;
+        const date = new Date(value);
+        return !Number.isNaN(date.getTime());
+    }
+    /**
+     * Check if an object is a GeoJSON Point
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isGeoPoint(value) {
+        return (value &&
+            typeof value === 'object' &&
+            value.type === 'Point' &&
+            Array.isArray(value.coordinates) &&
+            value.coordinates.length === 2);
+    }
+    /**
+     * All fields in Cosmos DB are sortable (no text analysis like Elasticsearch)
+     */
+    static isSortable(dataType) {
+        // Complex types cannot be sorted
+        return !['object', 'array'].includes(dataType);
+    }
+    /**
+     * Get supported operators for a given column type
+     */
+    static operatorsForColumnType(columnType) {
+        const result = ['Present', 'Missing'];
+        const equality = ['Equal', 'NotEqual', 'In', 'NotIn'];
+        if (typeof columnType === 'string') {
+            const orderables = ['LessThan', 'GreaterThan'];
+            const strings = ['Like', 'ILike', 'NotContains', 'Contains'];
+            if (['Boolean', 'Enum', 'Uuid'].includes(columnType)) {
+                result.push(...equality);
+            }
+            if (['Date', 'Dateonly', 'Number'].includes(columnType)) {
+                result.push(...equality, ...orderables);
+            }
+            if (['String'].includes(columnType)) {
+                result.push(...equality, ...orderables, ...strings);
+            }
+            if (['Point'].includes(columnType)) {
+                result.push(...equality);
+            }
+        }
+        // Cosmos DB supports arrays natively
+        if (Array.isArray(columnType)) {
+            result.push('IncludesAll');
+        }
+        return new Set(result);
+    }
+    /**
+     * Operators supported for the id field
+     */
+    static operatorsForId() {
+        return new Set(['Present', 'Missing', 'Equal', 'NotEqual', 'In', 'NotIn']);
+    }
+    /**
+     * Get the most specific common type from an array of types
+     */
+    static getMostSpecificType(types) {
+        if (types.length === 0)
+            return 'null';
+        if (types.length === 1)
+            return types[0];
+        // If all types are the same, return that type
+        const uniqueTypes = [...new Set(types)];
+        if (uniqueTypes.length === 1)
+            return uniqueTypes[0];
+        // If we have mixed types, check for special cases
+        // number + null = number (nullable)
+        if (uniqueTypes.every(t => ['number', 'null'].includes(t)))
+            return 'number';
+        if (uniqueTypes.every(t => ['string', 'null'].includes(t)))
+            return 'string';
+        if (uniqueTypes.every(t => ['boolean', 'null'].includes(t)))
+            return 'boolean';
+        if (uniqueTypes.every(t => ['date', 'null'].includes(t)))
+            return 'date';
+        // Mixed numeric types -> number
+        if (uniqueTypes.every(t => ['number', 'null'].includes(t)))
+            return 'number';
+        // Otherwise, treat as object (Json)
+        return 'object';
+    }
+}
+exports.default = TypeConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@forestadmin-experimental/datasource-cosmos",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "license": "GPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForestAdmin/forestadmin-experimental.git",
+    "directory": "packages/datasource-cosmos"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf coverage dist",
+    "lint": "eslint src test",
+    "test": "docker compose up -d; sleep 10 && jest",
+    "publish:package": "semantic-release"
+  },
+  "peerDependencies": {
+    "@forestadmin/datasource-toolkit": "^1.45.0",
+    "@azure/cosmos": "^4.0.0"
+  },
+  "devDependencies": {
+    "@forestadmin/datasource-toolkit": "^1.45.0",
+    "@azure/cosmos": "^4.0.0"
+  }
+}