@forestadmin-experimental/datasource-cosmos 1.0.0

package/dist/datasource.js

@@ -0,0 +1,87 @@
+"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"));
+class CosmosDataSource extends datasource_toolkit_1.BaseDataSource {
+    constructor(cosmosClient, collectionModels, logger, options) {
+        super();
+        if (!cosmosClient)
+            throw new Error('Invalid (null) CosmosClient instance.');
+        this.cosmosClient = cosmosClient;
+        // Creating collections
+        this.createCollections(collectionModels, logger);
+        if (options?.liveQueryConnections && options?.liveQueryDatabase) {
+            this.addNativeQueryConnection(options.liveQueryConnections, {
+                instance: this.cosmosClient,
+                databaseName: options.liveQueryDatabase,
+            });
+        }
+        logger?.('Info', 'CosmosDataSource - Built');
+    }
+    async createCollections(collectionModels, logger) {
+        collectionModels
+            // avoid schema reordering
+            .sort((modelA, modelB) => (modelA.name > modelB.name ? 1 : -1))
+            .forEach(model => {
+            const collection = new collection_1.default(this, model, logger, this.cosmosClient);
+            this.addCollection(collection);
+        });
+    }
+    async executeNativeQuery(connectionName, query, contextVariables = {}) {
+        if (!this.nativeQueryConnections[connectionName]) {
+            throw new Error(`Unknown connection name '${connectionName}'`);
+        }
+        const connection = this.nativeQueryConnections[connectionName];
+        const { querySpec, containerName } = this.parseQuery(query, contextVariables);
+        // Execute the query on the specified container
+        const database = connection.instance.database(connection.databaseName);
+        const container = database.container(containerName);
+        const { resources } = await container.items.query(querySpec).fetchAll();
+        return resources;
+    }
+    /**
+     * Parse the query string and extract container name and build SqlQuerySpec
+     * Expected format: "SELECT * FROM containerName WHERE ..."
+     */
+    parseQuery(query, contextVariables) {
+        // Extract container name from query (simple regex-based approach)
+        const fromMatch = query.match(/FROM\s+(\w+)/i);
+        if (!fromMatch) {
+            throw new Error('Invalid query: could not extract container name from FROM clause');
+        }
+        const containerName = fromMatch[1];
+        // Replace placeholders in query with parameterized values
+        const { parameterizedQuery, parameters } = this.replacePlaceholders(query, contextVariables);
+        const querySpec = {
+            query: parameterizedQuery,
+            parameters,
+        };
+        return { querySpec, containerName };
+    }
+    /**
+     * Replace placeholders ($variableName) with Cosmos DB parameters (@paramN)
+     */
+    replacePlaceholders(query, values) {
+        const parameters = [];
+        let paramCounter = 0;
+        const placeholderRegex = /\$(\w+)/g;
+        const parameterizedQuery = query.replace(placeholderRegex, (match, key) => {
+            if (key in values) {
+                const paramName = `@param${paramCounter}`;
+                paramCounter += 1;
+                // Type assertion: contextVariables should contain JSON-serializable values
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                parameters.push({ name: paramName, value: values[key] });
+                return paramName;
+            }
+            // If the variable is not in contextVariables, keep the original placeholder
+            return match;
+        });
+        return { parameterizedQuery, parameters };
+    }
+}
+exports.default = CosmosDataSource;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+import { CosmosClient, CosmosClientOptions } from '@azure/cosmos';
+import { DataSourceFactory } from '@forestadmin/datasource-toolkit';
+import { ConfigurationOptions } from './introspection/builder';
+export { default as CosmosCollection } from './collection';
+export { default as CosmosDataSource } from './datasource';
+export { default as TypeConverter } from './utils/type-converter';
+export { default as ModelCosmos } from './model-builder/model';
+export type { CosmosSchema } from './model-builder/model';
+/**
+ * Create a Cosmos DB datasource with an existing CosmosClient instance
+ * @param client Existing CosmosClient instance
+ * @param databaseName The Cosmos DB database name to introspect
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSourceWithExistingClient(existingClient, 'myDatabase', configurator =>
+ *   configurator.addCollectionFromContainer({
+ *     name: 'Users',
+ *     databaseName: 'myDatabase',
+ *     containerName: 'users-container'
+ *   })
+ * )
+ */
+export declare function createCosmosDataSourceWithExistingClient(client: CosmosClient, databaseName?: string): DataSourceFactory;
+/**
+ * Create a Cosmos DB datasource with connection details
+ * @param endpoint The Cosmos DB endpoint URL
+ * @param key The Cosmos DB access key
+ * @param databaseName Optional database name for auto-introspection
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSource(
+ *   'https://myaccount.documents.azure.com:443/',
+ *   'myAccessKey',
+ *   'myDatabase',
+ *   {
+ *     builder: configurator =>
+ *       configurator.addCollectionFromContainer({
+ *         name: 'Users',
+ *         databaseName: 'myDatabase',
+ *         containerName: 'users-container'
+ *       })
+ *   }
+ * )
+ */
+export declare function createCosmosDataSource(endpoint: string, key: string, databaseName?: string, options?: {
+    liveQueryConnections?: string;
+    liveQueryDatabase?: string;
+    builder?: ConfigurationOptions;
+    clientOptions?: CosmosClientOptions;
+}): DataSourceFactory;
+/**
+ * Create a Cosmos DB datasource for the local emulator
+ * @param databaseName Optional database name for auto-introspection
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSourceForEmulator('myDatabase', {
+ *   builder: configurator =>
+ *     configurator.addCollectionFromContainer({
+ *       name: 'Users',
+ *       databaseName: 'myDatabase',
+ *       containerName: 'users'
+ *     })
+ * })
+ */
+export declare function createCosmosDataSourceForEmulator(databaseName?: string, options?: {
+    liveQueryConnections?: string;
+    liveQueryDatabase?: string;
+    builder?: ConfigurationOptions;
+    clientOptions?: CosmosClientOptions;
+}): DataSourceFactory;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAU,MAAM,iCAAiC,CAAC;AAG5E,OAAO,EAAE,oBAAoB,EAA2B,MAAM,yBAAyB,CAAC;AAGxF,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC/D,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wCAAwC,CACtD,MAAM,EAAE,YAAY,EACpB,YAAY,CAAC,EAAE,MAAM,GACpB,iBAAiB,CAqBnB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;IACR,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACrC,GACA,iBAAiB,CAkCnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iCAAiC,CAC/C,YAAY,CAAC,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;IACR,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACrC,GACA,iBAAiB,CAOnB"}

package/dist/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCosmosDataSourceForEmulator = exports.createCosmosDataSource = exports.createCosmosDataSourceWithExistingClient = exports.ModelCosmos = exports.TypeConverter = exports.CosmosDataSource = exports.CosmosCollection = void 0;
+const cosmos_1 = require("@azure/cosmos");
+const datasource_1 = __importDefault(require("./datasource"));
+const builder_1 = require("./introspection/builder");
+const introspector_1 = __importDefault(require("./introspection/introspector"));
+var collection_1 = require("./collection");
+Object.defineProperty(exports, "CosmosCollection", { enumerable: true, get: function () { return __importDefault(collection_1).default; } });
+var datasource_2 = require("./datasource");
+Object.defineProperty(exports, "CosmosDataSource", { enumerable: true, get: function () { return __importDefault(datasource_2).default; } });
+var type_converter_1 = require("./utils/type-converter");
+Object.defineProperty(exports, "TypeConverter", { enumerable: true, get: function () { return __importDefault(type_converter_1).default; } });
+var model_1 = require("./model-builder/model");
+Object.defineProperty(exports, "ModelCosmos", { enumerable: true, get: function () { return __importDefault(model_1).default; } });
+/**
+ * Create a Cosmos DB datasource with an existing CosmosClient instance
+ * @param client Existing CosmosClient instance
+ * @param databaseName The Cosmos DB database name to introspect
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSourceWithExistingClient(existingClient, 'myDatabase', configurator =>
+ *   configurator.addCollectionFromContainer({
+ *     name: 'Users',
+ *     databaseName: 'myDatabase',
+ *     containerName: 'users-container'
+ *   })
+ * )
+ */
+function createCosmosDataSourceWithExistingClient(client, databaseName) {
+    return async (logger, options) => {
+        let collectionModels;
+        if (options) {
+            const builder = options(new builder_1.CosmosDatasourceBuilder(client));
+            collectionModels = await builder.createCollectionsFromConfiguration();
+        }
+        else if (databaseName) {
+            collectionModels = await introspector_1.default.introspect(client, databaseName, logger);
+        }
+        else {
+            collectionModels = [];
+        }
+        if (collectionModels.length === 0 && !options) {
+            const message = 'No collections were introspected. Please provide a databaseName or use the builder.';
+            logger?.('Warn', message);
+        }
+        return new datasource_1.default(client, collectionModels, logger);
+    };
+}
+exports.createCosmosDataSourceWithExistingClient = createCosmosDataSourceWithExistingClient;
+/**
+ * Create a Cosmos DB datasource with connection details
+ * @param endpoint The Cosmos DB endpoint URL
+ * @param key The Cosmos DB access key
+ * @param databaseName Optional database name for auto-introspection
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSource(
+ *   'https://myaccount.documents.azure.com:443/',
+ *   'myAccessKey',
+ *   'myDatabase',
+ *   {
+ *     builder: configurator =>
+ *       configurator.addCollectionFromContainer({
+ *         name: 'Users',
+ *         databaseName: 'myDatabase',
+ *         containerName: 'users-container'
+ *       })
+ *   }
+ * )
+ */
+function createCosmosDataSource(endpoint, key, databaseName, options) {
+    return async (logger) => {
+        const client = new cosmos_1.CosmosClient({
+            endpoint,
+            key,
+            ...options?.clientOptions,
+        });
+        const { liveQueryConnections, liveQueryDatabase, builder } = options || {};
+        let collectionModels;
+        if (builder) {
+            const datasourceBuilder = builder(new builder_1.CosmosDatasourceBuilder(client));
+            collectionModels = await datasourceBuilder.createCollectionsFromConfiguration();
+        }
+        else if (databaseName) {
+            collectionModels = await introspector_1.default.introspect(client, databaseName, logger);
+        }
+        else {
+            collectionModels = [];
+        }
+        if (collectionModels.length === 0 && !builder) {
+            const message = 'No collections were introspected. Please provide a databaseName or use the builder.';
+            logger?.('Warn', message);
+        }
+        return new datasource_1.default(client, collectionModels, logger, {
+            liveQueryConnections,
+            liveQueryDatabase,
+        });
+    };
+}
+exports.createCosmosDataSource = createCosmosDataSource;
+/**
+ * Create a Cosmos DB datasource for the local emulator
+ * @param databaseName Optional database name for auto-introspection
+ * @param options Optional configuration options
+ * @example
+ * .createCosmosDataSourceForEmulator('myDatabase', {
+ *   builder: configurator =>
+ *     configurator.addCollectionFromContainer({
+ *       name: 'Users',
+ *       databaseName: 'myDatabase',
+ *       containerName: 'users'
+ *     })
+ * })
+ */
+function createCosmosDataSourceForEmulator(databaseName, options) {
+    // Default emulator connection details
+    const endpoint = 'https://localhost:8081';
+    const key = 'C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==';
+    return createCosmosDataSource(endpoint, key, databaseName, options);
+}
+exports.createCosmosDataSourceForEmulator = createCosmosDataSourceForEmulator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/introspection/builder.d.ts

@@ -0,0 +1,68 @@
+import { CosmosClient } from '@azure/cosmos';
+import { FieldSchema } from '@forestadmin/datasource-toolkit';
+import ModelCosmos from '../model-builder/model';
+export type OverrideTypeConverter = (field: {
+    fieldName: string;
+    attribute: {
+        type: string;
+        nullable?: boolean;
+        indexed?: boolean;
+    };
+    generatedFieldSchema: FieldSchema;
+}) => void | FieldSchema;
+export type CosmosCollectionBase = {
+    /**
+     * Give the name of the collection (Forest Admin collection name)
+     */
+    name: string;
+    /**
+     * Allow to override the type converter
+     */
+    overrideTypeConverter?: OverrideTypeConverter;
+    /**
+     * Enabling `enableCount` allows the pagination widget to display the total number of pages
+     * in this collection while browsing records.
+     *
+     * _It is enabled by default but can be disabled for performance reasons._
+     */
+    enableCount?: boolean;
+};
+export type CosmosCollectionFromContainerOptions = {
+    /**
+     * The Cosmos DB database name
+     */
+    databaseName: string;
+    /**
+     * The Cosmos DB container name
+     */
+    containerName: string;
+    /**
+     * The partition key path for this container (e.g., "/userId")
+     */
+    partitionKeyPath?: string;
+    /**
+     * Number of sample documents to analyze for schema inference (default: 100)
+     */
+    sampleSize?: number;
+} & CosmosCollectionBase;
+export type ConfigurationOptions = (configurator: CosmosDatasourceOptionsBuilder) => CosmosDatasourceOptionsBuilder;
+export interface CosmosDatasourceOptionsBuilder {
+    /**
+     * Add a collection from a Cosmos DB container
+     */
+    addCollectionFromContainer(options: CosmosCollectionFromContainerOptions): this;
+}
+/**
+ * Builder pattern to ease adding collections from Cosmos DB
+ */
+export declare class CosmosDatasourceBuilder implements CosmosDatasourceOptionsBuilder {
+    private readonly cosmosClient;
+    protected collectionsPromises: Array<Promise<ModelCosmos>>;
+    constructor(cosmosClient: CosmosClient);
+    addCollectionFromContainer({ name, databaseName, containerName, partitionKeyPath, overrideTypeConverter, enableCount, sampleSize, }: CosmosCollectionFromContainerOptions): this;
+    /**
+     * Internal usages only - the client only sees CosmosDatasourceOptionsBuilder interface
+     */
+    createCollectionsFromConfiguration(): Promise<ModelCosmos[]>;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/introspection/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/introspection/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D,OAAO,WAAW,MAAM,wBAAwB,CAAC;AAEjD,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACnE,oBAAoB,EAAE,WAAW,CAAC;CACnC,KAAK,IAAI,GAAG,WAAW,CAAC;AAEzB,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAE9C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,oBAAoB,CAAC;AAEzB,MAAM,MAAM,oBAAoB,GAAG,CACjC,YAAY,EAAE,8BAA8B,KACzC,8BAA8B,CAAC;AAEpC,MAAM,WAAW,8BAA8B;IAC7C;;OAEG;IACH,0BAA0B,CAAC,OAAO,EAAE,oCAAoC,GAAG,IAAI,CAAC;CACjF;AAED;;GAEG;AACH,qBAAa,uBAAwB,YAAW,8BAA8B;IAC5E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAE5C,SAAS,CAAC,mBAAmB,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAM;gBAEpD,YAAY,EAAE,YAAY;IAI/B,0BAA0B,CAAC,EAChC,IAAI,EACJ,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,WAAW,EACX,UAAgB,GACjB,EAAE,oCAAoC,GAAG,IAAI;IAqB9C;;OAEG;IACU,kCAAkC,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;CAG1E"}

package/dist/introspection/builder.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosDatasourceBuilder = void 0;
+const container_introspector_1 = __importDefault(require("./container-introspector"));
+/**
+ * Builder pattern to ease adding collections from Cosmos DB
+ */
+class CosmosDatasourceBuilder {
+    constructor(cosmosClient) {
+        this.collectionsPromises = [];
+        this.cosmosClient = cosmosClient;
+    }
+    addCollectionFromContainer({ name, databaseName, containerName, partitionKeyPath, overrideTypeConverter, enableCount, sampleSize = 100, }) {
+        this.collectionsPromises.push((async () => {
+            const model = await (0, container_introspector_1.default)(this.cosmosClient, name, databaseName, containerName, partitionKeyPath, sampleSize, overrideTypeConverter, enableCount);
+            return model;
+        })());
+        return this;
+    }
+    /**
+     * Internal usages only - the client only sees CosmosDatasourceOptionsBuilder interface
+     */
+    async createCollectionsFromConfiguration() {
+        return Promise.all(this.collectionsPromises);
+    }
+}
+exports.CosmosDatasourceBuilder = CosmosDatasourceBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRyb3NwZWN0aW9uL2J1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBR0Esc0ZBQTJEO0FBOEQzRDs7R0FFRztBQUNILE1BQWEsdUJBQXVCO0lBS2xDLFlBQVksWUFBMEI7UUFGNUIsd0JBQW1CLEdBQWdDLEVBQUUsQ0FBQztRQUc5RCxJQUFJLENBQUMsWUFBWSxHQUFHLFlBQVksQ0FBQztJQUNuQyxDQUFDO0lBRU0sMEJBQTBCLENBQUMsRUFDaEMsSUFBSSxFQUNKLFlBQVksRUFDWixhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2hCLHFCQUFxQixFQUNyQixXQUFXLEVBQ1gsVUFBVSxHQUFHLEdBQUcsR0FDcUI7UUFDckMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FDM0IsQ0FBQyxLQUFLLElBQUksRUFBRTtZQUNWLE1BQU0sS0FBSyxHQUFHLE1BQU0sSUFBQSxnQ0FBbUIsRUFDckMsSUFBSSxDQUFDLFlBQVksRUFDakIsSUFBSSxFQUNKLFlBQVksRUFDWixhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2hCLFVBQVUsRUFDVixxQkFBcUIsRUFDckIsV0FBVyxDQUNaLENBQUM7WUFFRixPQUFPLEtBQUssQ0FBQztRQUNmLENBQUMsQ0FBQyxFQUFFLENBQ0wsQ0FBQztRQUVGLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLGtDQUFrQztRQUM3QyxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFDL0MsQ0FBQztDQUNGO0FBNUNELDBEQTRDQyJ9

package/dist/introspection/container-introspector.d.ts

@@ -0,0 +1,27 @@
+import { CosmosClient } from '@azure/cosmos';
+import { OverrideTypeConverter } from './builder';
+import ModelCosmos from '../model-builder/model';
+export interface IntrospectionOptions {
+    /**
+     * Whether to flatten nested objects into dot-notation fields
+     * Example: { address: { city: 'NYC' } } becomes { 'address.city': 'NYC' }
+     * Default: true (recommended for Forest Admin compatibility)
+     */
+    flattenNestedObjects?: boolean;
+    /**
+     * Maximum depth for nested object introspection
+     * Default: 5
+     */
+    maxDepth?: number;
+    /**
+     * Whether to include array items introspection
+     * Default: false (arrays are treated as Json type)
+     */
+    introspectArrayItems?: boolean;
+}
+/**
+ * Introspect a Cosmos DB container to infer the schema from sample documents
+ * with support for complex nested objects
+ */
+export default function introspectContainerV2(cosmosClient: CosmosClient, collectionName: string, databaseName: string, containerName: string, partitionKeyPath?: string, sampleSize?: number, overrideTypeConverter?: OverrideTypeConverter, enableCount?: boolean, options?: IntrospectionOptions): Promise<ModelCosmos>;
+//# sourceMappingURL=container-introspector.d.ts.map

package/dist/introspection/container-introspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-introspector.d.ts","sourceRoot":"","sources":["../../src/introspection/container-introspector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,WAA6B,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,wBAA8B,qBAAqB,CACjD,YAAY,EAAE,YAAY,EAC1B,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,SAAM,EAChB,qBAAqB,CAAC,EAAE,qBAAqB,EAC7C,WAAW,CAAC,EAAE,OAAO,EACrB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,WAAW,CAAC,CAuCtB"}

package/dist/introspection/container-introspector.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = __importDefault(require("../model-builder/model"));
+const type_converter_1 = __importDefault(require("../utils/type-converter"));
+/**
+ * Introspect a Cosmos DB container to infer the schema from sample documents
+ * with support for complex nested objects
+ */
+async function introspectContainerV2(cosmosClient, collectionName, databaseName, containerName, partitionKeyPath, sampleSize = 100, overrideTypeConverter, enableCount, options = {}) {
+    const { flattenNestedObjects = true, maxDepth = 5, introspectArrayItems = false } = options;
+    const database = cosmosClient.database(databaseName);
+    const container = database.container(containerName);
+    // Get container metadata to determine partition key if not provided
+    let actualPartitionKeyPath = partitionKeyPath;
+    if (!actualPartitionKeyPath) {
+        const { resource: containerDef } = await container.read();
+        actualPartitionKeyPath = containerDef.partitionKey?.paths?.[0] || '/id';
+    }
+    // Sample documents to infer schema
+    const querySpec = {
+        query: `SELECT TOP ${sampleSize} * FROM c`,
+    };
+    const { resources: sampleDocuments } = await container.items.query(querySpec).fetchAll();
+    // Infer schema from sample documents with nested object support
+    const schema = inferSchemaFromDocuments(sampleDocuments, flattenNestedObjects, maxDepth, introspectArrayItems);
+    return new model_1.default(cosmosClient, collectionName, databaseName, containerName, actualPartitionKeyPath, schema, overrideTypeConverter, enableCount);
+}
+exports.default = introspectContainerV2;
+/**
+ * Infer schema from a collection of sample documents with nested support
+ */
+function inferSchemaFromDocuments(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+documents, flattenNestedObjects, maxDepth, introspectArrayItems) {
+    if (documents.length === 0) {
+        return {};
+    }
+    const schema = {};
+    const fieldTypes = {};
+    const fieldPresence = {}; // Track how many docs have each field
+    // Analyze each document to collect field types
+    for (const doc of documents) {
+        const fieldsInDoc = new Set();
+        analyzeDocument(doc, fieldTypes, '', 0, maxDepth, flattenNestedObjects, introspectArrayItems, fieldsInDoc);
+        // Track field presence
+        for (const field of fieldsInDoc) {
+            fieldPresence[field] = (fieldPresence[field] || 0) + 1;
+        }
+    }
+    // Convert collected field types to schema
+    for (const [fieldName, types] of Object.entries(fieldTypes)) {
+        // Skip Cosmos DB system fields (start with _)
+        if (!fieldName.startsWith('_') || fieldName === '_id') {
+            // Get the most specific common type
+            const commonType = type_converter_1.default.getMostSpecificType(types);
+            // Field is nullable if it contains null OR is not present in all documents
+            const nullable = types.includes('null') || fieldPresence[fieldName] < documents.length;
+            schema[fieldName] = {
+                type: commonType,
+                nullable,
+                indexed: true, // Assume all fields can be indexed in Cosmos DB
+            };
+        }
+    }
+    return schema;
+}
+/**
+ * Recursively analyze a document to collect field types with nested object support
+ */
+function analyzeDocument(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+obj, fieldTypes, prefix, depth, maxDepth, flattenNestedObjects, introspectArrayItems, fieldsInDoc) {
+    // Helper to record a field type
+    const recordField = (fieldName, type) => {
+        if (!fieldTypes[fieldName]) {
+            fieldTypes[fieldName] = [];
+        }
+        fieldTypes[fieldName].push(type);
+        if (fieldsInDoc && fieldName) {
+            fieldsInDoc.add(fieldName);
+        }
+    };
+    if (obj === null || obj === undefined) {
+        if (prefix) {
+            recordField(prefix, 'null');
+        }
+        return;
+    }
+    // Stop recursion if max depth reached
+    if (depth >= maxDepth) {
+        if (prefix) {
+            recordField(prefix, 'object');
+        }
+        return;
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        if (prefix) {
+            recordField(prefix, 'array');
+        }
+        // Optionally introspect array items
+        if (introspectArrayItems && obj.length > 0) {
+            // Analyze first few items to infer array item type
+            const itemsToAnalyze = obj.slice(0, Math.min(5, obj.length));
+            for (const item of itemsToAnalyze) {
+                if (typeof item === 'object' && item !== null) {
+                    analyzeDocument(item, fieldTypes, `${prefix}[]`, depth + 1, maxDepth, flattenNestedObjects, introspectArrayItems, fieldsInDoc);
+                }
+            }
+        }
+        return;
+    }
+    // Handle objects
+    if (typeof obj === 'object') {
+        // Check for special types first
+        if (obj instanceof Date) {
+            if (prefix) {
+                recordField(prefix, 'date');
+            }
+            return;
+        }
+        if (isGeoPoint(obj)) {
+            if (prefix) {
+                recordField(prefix, 'point');
+            }
+            return;
+        }
+        // Regular object - recursively analyze properties
+        for (const [key, value] of Object.entries(obj)) {
+            const fieldName = prefix ? `${prefix}.${key}` : key;
+            if (value &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                flattenNestedObjects &&
+                !(value instanceof Date) &&
+                !isGeoPoint(value)) {
+                // Recursively analyze nested objects if flattening is enabled
+                analyzeDocument(value, fieldTypes, fieldName, depth + 1, maxDepth, flattenNestedObjects, introspectArrayItems, fieldsInDoc);
+            }
+            else {
+                // For non-nested or non-flatten mode
+                const inferredType = type_converter_1.default.inferTypeFromValue(value);
+                recordField(fieldName, inferredType);
+            }
+        }
+        return;
+    }
+    // Primitive values
+    if (prefix) {
+        const inferredType = type_converter_1.default.inferTypeFromValue(obj);
+        recordField(prefix, inferredType);
+    }
+}
+/**
+ * Check if an object is a GeoJSON Point
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isGeoPoint(value) {
+    return (value &&
+        typeof value === 'object' &&
+        value.type === 'Point' &&
+        Array.isArray(value.coordinates) &&
+        value.coordinates.length === 2);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/introspection/introspector.d.ts

@@ -0,0 +1,18 @@
+import { CosmosClient } from '@azure/cosmos';
+import { Logger } from '@forestadmin/datasource-toolkit';
+import ModelCosmos from '../model-builder/model';
+export default class Introspector {
+    /**
+     * Introspect all containers in a Cosmos DB database
+     */
+    static introspect(cosmosClient: CosmosClient, databaseName: string, logger?: Logger): Promise<ModelCosmos[]>;
+    /**
+     * Introspect all containers in the specified database
+     */
+    private static introspectAll;
+    /**
+     * Introspect a specific container
+     */
+    static introspectContainer(cosmosClient: CosmosClient, databaseName: string, containerName: string, sampleSize?: number, logger?: Logger): Promise<ModelCosmos>;
+}
+//# sourceMappingURL=introspector.d.ts.map

package/dist/introspection/introspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspector.d.ts","sourceRoot":"","sources":["../../src/introspection/introspector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAGzD,OAAO,WAAW,MAAM,wBAAwB,CAAC;AAEjD,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B;;OAEG;WACU,UAAU,CACrB,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,EAAE,CAAC;IAMzB;;OAEG;mBACkB,aAAa;IAuDlC;;OAEG;WACU,mBAAmB,CAC9B,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC;CAgBxB"}