@owox/backend 0.23.0-next-20260410055152 → 0.23.0-next-20260413072944

package/dist/src/data-marts/data-storage-types/databricks/adapters/databricks-api.adapter.d.ts

@@ -2,6 +2,13 @@ import { DatabricksConfig } from '../schemas/databricks-config.schema';
 import { DatabricksCredentials } from '../schemas/databricks-credentials.schema';
 import { DatabricksQueryMetadata } from '../interfaces/databricks-query-metadata';
 import { DatabricksQueryExplainJsonResponse } from '../interfaces/databricks-query-explain-json-response';
+export interface DatabricksQueryCursor {
+    queryId: string;
+    fetchChunk(maxRows?: number): Promise<Record<string, unknown>[]>;
+    hasMoreRows(): Promise<boolean>;
+    getColumns(): Promise<string[] | null>;
+    close(): Promise<void>;
+}
 export declare class DatabricksApiAdapter {
     private readonly credentials;
     private readonly config;
@@ -26,6 +33,11 @@ export declare class DatabricksApiAdapter {
     getTableSchemaWithPath(catalogName: string | undefined, schemaName: string | undefined, tableName: string): Promise<Record<string, unknown>[]>;
     createView(viewName: string, query: string): Promise<void>;
     fetchResults(query: string, maxRows?: number): Promise<Record<string, unknown>[]>;
+    openQueryCursor(query: string): Promise<DatabricksQueryCursor>;
+    private createCursor;
+    private resolveColumns;
+    private assertCursorIsConsistent;
+    private closeCursorSafely;
     getTableExtendedInfo(tableName: string): Promise<Record<string, unknown>[]>;
     getPrimaryKeyColumns(fullyQualifiedName: string): Promise<string[]>;
 }

package/dist/src/data-marts/data-storage-types/databricks/adapters/databricks-api.adapter.js

@@ -6,6 +6,7 @@ const sql_1 = require("@databricks/sql");
 const IDBSQLLogger_1 = require("@databricks/sql/dist/contracts/IDBSQLLogger");
 const internal_helpers_1 = require("@owox/internal-helpers");
 const databricks_identifier_utils_1 = require("../utils/databricks-identifier.utils");
+const DEFAULT_FETCH_CHUNK_MAX_ROWS = 1000;
 class SilentDatabricksLogger {
     logger = new common_1.Logger(SilentDatabricksLogger.name);
     log(level, message) {
@@ -74,23 +75,38 @@ class DatabricksApiAdapter {
         return this.session;
     }
     async executeQuery(query) {
-        const session = await this.ensureConnection();
+        const cursor = await this.openQueryCursor(query);
+        const rows = [];
+        let queryError = null;
         try {
-            const operation = await session.executeStatement(query);
-            const result = await operation.fetchAll();
-            await operation.close();
-            const queryId = operation.id || '';
-            const rows = result;
+            while (true) {
+                const chunk = await cursor.fetchChunk(DEFAULT_FETCH_CHUNK_MAX_ROWS);
+                if (chunk.length > 0) {
+                    rows.push(...chunk);
+                }
+                if (chunk.length === 0) {
+                    await this.assertCursorIsConsistent(cursor);
+                    break;
+                }
+                const hasMoreRows = await cursor.hasMoreRows();
+                if (!hasMoreRows) {
+                    break;
+                }
+            }
             this.logger.debug(`Query executed: ${query}`);
             this.logger.debug(`Query returned ${rows?.length || 0} rows`);
             const metadata = {
-                queryId,
-                statementId: queryId,
+                queryId: cursor.queryId,
+                statementId: cursor.queryId,
             };
-            return { queryId, rows, metadata };
+            return { queryId: cursor.queryId, rows, metadata };
         }
         catch (error) {
-            throw new Error(`${DatabricksApiAdapter.DATABRICKS_QUERY_ERROR_PREFIX} ${(0, internal_helpers_1.castError)(error).message}, ${query}`);
+            queryError = new Error(`${DatabricksApiAdapter.DATABRICKS_QUERY_ERROR_PREFIX} ${(0, internal_helpers_1.castError)(error).message}, ${query}`);
+            throw queryError;
+        }
+        finally {
+            await this.closeCursorSafely(cursor, 'query execution', queryError);
         }
     }
     async executeQueryAndFetchAll(query) {
@@ -160,17 +176,96 @@ class DatabricksApiAdapter {
         await this.executeQuery(createViewQuery);
     }
     async fetchResults(query, maxRows = 1000) {
+        if (maxRows <= 0) {
+            return [];
+        }
+        const cursor = await this.openQueryCursor(query);
+        const rows = [];
+        let fetchError = null;
+        try {
+            while (rows.length < maxRows) {
+                const remainingRows = maxRows - rows.length;
+                const chunk = await cursor.fetchChunk(remainingRows);
+                if (chunk.length > 0) {
+                    rows.push(...chunk);
+                }
+                if (chunk.length === 0) {
+                    await this.assertCursorIsConsistent(cursor);
+                    break;
+                }
+                const hasMoreRows = await cursor.hasMoreRows();
+                if (!hasMoreRows) {
+                    break;
+                }
+            }
+            return rows;
+        }
+        catch (error) {
+            fetchError = new Error(`Failed to fetch results: ${(0, internal_helpers_1.castError)(error).message}`);
+            throw fetchError;
+        }
+        finally {
+            await this.closeCursorSafely(cursor, 'result fetch', fetchError);
+        }
+    }
+    async openQueryCursor(query) {
         const session = await this.ensureConnection();
         try {
-            const operation = await session.executeStatement(query, {
-                maxRows,
-            });
-            const result = await operation.fetchAll();
-            await operation.close();
-            return result;
+            const operation = await session.executeStatement(query);
+            const queryId = operation.id || '';
+            this.logger.debug(`Query cursor opened, queryId: ${queryId}`);
+            return this.createCursor(operation, queryId);
         }
         catch (error) {
-            throw new Error(`Failed to fetch results: ${(0, internal_helpers_1.castError)(error).message}`);
+            throw new Error(`${DatabricksApiAdapter.DATABRICKS_QUERY_ERROR_PREFIX} ${(0, internal_helpers_1.castError)(error).message}, ${query}`);
+        }
+    }
+    createCursor(operation, queryId) {
+        let isClosed = false;
+        return {
+            queryId,
+            fetchChunk: async (maxRows) => {
+                const chunk = await operation.fetchChunk({
+                    maxRows: maxRows ?? DEFAULT_FETCH_CHUNK_MAX_ROWS,
+                });
+                return chunk;
+            },
+            hasMoreRows: async () => operation.hasMoreRows(),
+            getColumns: async () => this.resolveColumns(operation),
+            close: async () => {
+                if (isClosed) {
+                    return;
+                }
+                isClosed = true;
+                await operation.close();
+            },
+        };
+    }
+    async resolveColumns(operation) {
+        const schema = await operation.getSchema();
+        if (!schema?.columns?.length) {
+            return null;
+        }
+        const columns = schema.columns.map(column => column.columnName).filter(Boolean);
+        return columns.length > 0 ? columns : null;
+    }
+    async assertCursorIsConsistent(cursor) {
+        const hasMoreRows = await cursor.hasMoreRows();
+        if (hasMoreRows) {
+            throw new Error('Databricks cursor returned an empty chunk while indicating more rows');
+        }
+    }
+    async closeCursorSafely(cursor, context, primaryError) {
+        try {
+            await cursor.close();
+        }
+        catch (error) {
+            const closeError = (0, internal_helpers_1.castError)(error);
+            if (primaryError) {
+                this.logger.warn(`Failed to close Databricks cursor after ${context}: ${closeError.message}. Preserving original error: ${primaryError.message}`);
+                return;
+            }
+            throw new Error(`Failed to close Databricks cursor after ${context}: ${closeError.message}`);
         }
     }
     async getTableExtendedInfo(tableName) {

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-data-mart-schema.provider.js

@@ -69,8 +69,7 @@ let DatabricksDataMartSchemaProvider = DatabricksDataMartSchemaProvider_1 = clas
                 };
             }
             this.logger.debug('Table does not exist yet, deriving schema from query');
-            const baseQuery = this.queryBuilder.buildQuery(definition);
-            const query = `${baseQuery} LIMIT 0`;
+            const query = this.queryBuilder.buildQuery(definition, { limit: 0 });
             const { rows: _rows } = await adapter.executeQuery(query);
             const describeQuery = `DESCRIBE QUERY ${query}`;
             const describeResult = await adapter.executeQuery(describeQuery);

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-query.builder.d.ts

@@ -1,7 +1,7 @@
 import { DataMartDefinition } from '../../../dto/schemas/data-mart-table-definitions/data-mart-definition';
 import { DataStorageType } from '../../enums/data-storage-type.enum';
-import { DataMartQueryBuilder } from '../../interfaces/data-mart-query-builder.interface';
+import { DataMartQueryBuilder, DataMartQueryOptions } from '../../interfaces/data-mart-query-builder.interface';
 export declare class DatabricksQueryBuilder implements DataMartQueryBuilder {
     readonly type = DataStorageType.DATABRICKS;
-    buildQuery(definition: DataMartDefinition): string;
+    buildQuery(definition: DataMartDefinition, queryOptions?: DataMartQueryOptions): string;
 }

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-query.builder.js

@@ -13,17 +13,18 @@ const data_storage_type_enum_1 = require("../../enums/data-storage-type.enum");
 const databricks_identifier_utils_1 = require("../utils/databricks-identifier.utils");
 let DatabricksQueryBuilder = class DatabricksQueryBuilder {
     type = data_storage_type_enum_1.DataStorageType.DATABRICKS;
-    buildQuery(definition) {
+    buildQuery(definition, queryOptions) {
+        let query;
         if ((0, data_mart_definition_guards_1.isTableDefinition)(definition) || (0, data_mart_definition_guards_1.isViewDefinition)(definition)) {
             const parts = definition.fullyQualifiedName.split('.');
-            return `SELECT * FROM ${(0, databricks_identifier_utils_1.escapeFullyQualifiedIdentifier)(parts)}`;
+            query = `SELECT * FROM ${(0, databricks_identifier_utils_1.escapeFullyQualifiedIdentifier)(parts)}`;
         }
         else if ((0, data_mart_definition_guards_1.isConnectorDefinition)(definition)) {
             const parts = definition.connector.storage.fullyQualifiedName.split('.');
-            return `SELECT * FROM ${(0, databricks_identifier_utils_1.escapeFullyQualifiedIdentifier)(parts)}`;
+            query = `SELECT * FROM ${(0, databricks_identifier_utils_1.escapeFullyQualifiedIdentifier)(parts)}`;
         }
         else if ((0, data_mart_definition_guards_1.isSqlDefinition)(definition)) {
-            return definition.sqlQuery;
+            query = definition.sqlQuery.trim();
         }
         else if ((0, data_mart_definition_guards_1.isTablePatternDefinition)(definition)) {
             throw new Error('Table pattern definitions are not supported for Databricks');
@@ -31,6 +32,11 @@ let DatabricksQueryBuilder = class DatabricksQueryBuilder {
         else {
             throw new Error('Invalid data mart definition');
         }
+        if (queryOptions?.limit !== undefined) {
+            const cleanQuery = query.endsWith(';') ? query.slice(0, -1) : query;
+            query = `SELECT * FROM (${cleanQuery}) LIMIT ${queryOptions.limit}`;
+        }
+        return query;
     }
 };
 exports.DatabricksQueryBuilder = DatabricksQueryBuilder;

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-report-reader.service.d.ts

@@ -16,11 +16,13 @@ export declare class DatabricksReportReader implements DataStorageReportReader {
     private readonly logger;
     readonly type = DataStorageType.DATABRICKS;
     private adapter;
+    private queryCursor;
     private reportDataHeaders;
     private reportConfig;
     private queryId?;
     private currentRowIndex;
-    private allRows;
+    private hasMoreRows;
+    private pendingRowsToSkip;
     constructor(adapterFactory: DatabricksApiAdapterFactory, queryBuilder: DatabricksQueryBuilder, headersGenerator: DatabricksReportHeadersGenerator);
     prepareReportData(report: Report): Promise<ReportDataDescription>;
     readReportDataBatch(_batchId?: string, maxDataRows?: number): Promise<ReportDataBatch>;
@@ -29,4 +31,5 @@ export declare class DatabricksReportReader implements DataStorageReportReader {
     private serializeValue;
     getState(): DatabricksReaderState | null;
     initFromState(state: DataStorageReportReaderState, reportDataHeaders: ReportDataHeader[]): Promise<void>;
+    private skipPendingRows;
 }

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-report-reader.service.js

@@ -12,6 +12,7 @@ var DatabricksReportReader_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabricksReportReader = void 0;
 const common_1 = require("@nestjs/common");
+const internal_helpers_1 = require("@owox/internal-helpers");
 const data_storage_type_enum_1 = require("../../enums/data-storage-type.enum");
 const report_data_batch_dto_1 = require("../../../dto/domain/report-data-batch.dto");
 const report_data_description_dto_1 = require("../../../dto/domain/report-data-description.dto");
@@ -27,11 +28,13 @@ let DatabricksReportReader = DatabricksReportReader_1 = class DatabricksReportRe
     logger = new common_1.Logger(DatabricksReportReader_1.name);
     type = data_storage_type_enum_1.DataStorageType.DATABRICKS;
     adapter;
+    queryCursor = null;
     reportDataHeaders;
     reportConfig;
     queryId;
     currentRowIndex = 0;
-    allRows = [];
+    hasMoreRows = false;
+    pendingRowsToSkip = 0;
     constructor(adapterFactory, queryBuilder, headersGenerator) {
         this.adapterFactory = adapterFactory;
         this.queryBuilder = queryBuilder;
@@ -53,33 +56,51 @@ let DatabricksReportReader = DatabricksReportReader_1 = class DatabricksReportRe
         this.adapter = await this.adapterFactory.createFromStorage(storage);
         const query = this.queryBuilder.buildQuery(definition);
         this.logger.debug(`Executing query: ${query}`);
-        const result = await this.adapter.executeQuery(query);
-        this.queryId = result.queryId;
-        this.allRows = result.rows || [];
+        this.queryCursor = await this.adapter.openQueryCursor(query);
+        this.queryId = this.queryCursor.queryId;
         this.currentRowIndex = 0;
-        this.logger.debug(`Query executed, queryId: ${this.queryId}, total rows: ${this.allRows.length}`);
+        this.pendingRowsToSkip = 0;
+        this.hasMoreRows = true;
+        this.logger.debug(`Query cursor opened, queryId: ${this.queryId}`);
         return new report_data_description_dto_1.ReportDataDescription(this.reportDataHeaders);
     }
     async readReportDataBatch(_batchId, maxDataRows = 1000) {
-        if (!this.reportDataHeaders || !this.queryId) {
+        if (!this.reportDataHeaders || !this.queryCursor || !this.queryId) {
             throw new Error('Report data must be prepared before read');
         }
-        const startIndex = this.currentRowIndex;
-        const endIndex = Math.min(startIndex + maxDataRows, this.allRows.length);
-        const rows = this.allRows.slice(startIndex, endIndex);
+        if (this.pendingRowsToSkip > 0) {
+            await this.skipPendingRows();
+        }
+        const rows = await this.queryCursor.fetchChunk(maxDataRows);
         const mappedRows = this.mapRowsToHeaders(rows);
-        this.currentRowIndex = endIndex;
-        const hasMoreData = endIndex < this.allRows.length;
+        this.currentRowIndex += rows.length;
+        const hasMoreData = rows.length > 0 ? await this.queryCursor.hasMoreRows() : false;
+        this.hasMoreRows = hasMoreData;
         const nextBatchId = hasMoreData ? this.currentRowIndex.toString() : null;
-        this.logger.debug(`Returning batch with ${rows.length} rows (from index ${startIndex} to ${endIndex})`);
+        this.logger.debug(`Returning batch with ${rows.length} rows (rows read total: ${this.currentRowIndex})`);
         return new report_data_batch_dto_1.ReportDataBatch(mappedRows, nextBatchId);
     }
     async finalize() {
         this.logger.debug('Finalizing report read');
+        let closeError = null;
+        if (this.queryCursor) {
+            try {
+                await this.queryCursor.close();
+            }
+            catch (error) {
+                closeError = (0, internal_helpers_1.castError)(error);
+                this.logger.warn(`Failed to close Databricks cursor during finalize: ${closeError.message}`);
+            }
+            finally {
+                this.queryCursor = null;
+            }
+        }
         if (this.adapter) {
             await this.adapter.destroy();
         }
-        this.allRows = [];
+        if (closeError) {
+            throw closeError;
+        }
     }
     mapRowsToHeaders(rows) {
         const headerNames = this.reportDataHeaders.map(h => h.name);
@@ -147,17 +168,42 @@ let DatabricksReportReader = DatabricksReportReader_1 = class DatabricksReportRe
             type: data_storage_type_enum_1.DataStorageType.DATABRICKS,
             queryId: this.queryId,
             rowsRead: this.currentRowIndex,
-            hasMore: this.currentRowIndex < this.allRows.length,
+            hasMore: this.hasMoreRows,
         };
     }
     async initFromState(state, reportDataHeaders) {
         if (!(0, databricks_reader_state_interface_1.isDatabricksReaderState)(state)) {
             throw new Error('Invalid state type for Databricks reader');
         }
-        this.queryId = state.queryId;
-        this.currentRowIndex = state.rowsRead;
+        if (!this.queryCursor || !this.queryId) {
+            throw new Error('Report data must be prepared before state restore');
+        }
+        this.currentRowIndex = 0;
+        this.pendingRowsToSkip = state.rowsRead;
+        this.hasMoreRows = state.hasMore;
         this.reportDataHeaders = reportDataHeaders;
-        this.logger.debug(`Restored from state: queryId=${this.queryId}, currentRow=${this.currentRowIndex}`);
+        this.logger.debug(`Restored from state: cachedQueryId=${state.queryId}, activeQueryId=${this.queryId}, rowsToSkip=${this.pendingRowsToSkip}`);
+    }
+    async skipPendingRows() {
+        if (!this.queryCursor) {
+            throw new Error('Report data must be prepared before skip');
+        }
+        while (this.pendingRowsToSkip > 0) {
+            const chunkSize = Math.min(this.pendingRowsToSkip, 1000);
+            const skippedRows = await this.queryCursor.fetchChunk(chunkSize);
+            if (!skippedRows.length) {
+                this.pendingRowsToSkip = 0;
+                this.hasMoreRows = false;
+                return;
+            }
+            this.pendingRowsToSkip -= skippedRows.length;
+            this.currentRowIndex += skippedRows.length;
+            this.hasMoreRows = await this.queryCursor.hasMoreRows();
+            if (!this.hasMoreRows) {
+                this.pendingRowsToSkip = 0;
+                return;
+            }
+        }
     }
 };
 exports.DatabricksReportReader = DatabricksReportReader;

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-sql-run.executor.d.ts

@@ -10,6 +10,7 @@ export declare class DatabricksSqlRunExecutor implements SqlRunExecutor {
     private readonly adapterFactory;
     private readonly queryBuilder;
     readonly type = DataStorageType.DATABRICKS;
+    private readonly logger;
     constructor(adapterFactory: DatabricksApiAdapterFactory, queryBuilder: DatabricksQueryBuilder);
     execute<Row = Record<string, unknown>>(credentials: DataStorageCredentials, config: DataStorageConfig, definition: DataMartDefinition, sql: string | undefined, options?: {
         maxRowsPerBatch?: number;

package/dist/src/data-marts/data-storage-types/databricks/services/databricks-sql-run.executor.js

@@ -8,19 +8,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var DatabricksSqlRunExecutor_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabricksSqlRunExecutor = void 0;
 const common_1 = require("@nestjs/common");
+const internal_helpers_1 = require("@owox/internal-helpers");
 const data_storage_type_enum_1 = require("../../enums/data-storage-type.enum");
 const data_storage_credentials_guards_1 = require("../../data-storage-credentials.guards");
 const data_storage_config_guards_1 = require("../../data-storage-config.guards");
 const databricks_api_adapter_factory_1 = require("../adapters/databricks-api-adapter.factory");
 const sql_run_batch_dto_1 = require("../../../dto/domain/sql-run-batch.dto");
 const databricks_query_builder_1 = require("./databricks-query.builder");
-let DatabricksSqlRunExecutor = class DatabricksSqlRunExecutor {
+let DatabricksSqlRunExecutor = DatabricksSqlRunExecutor_1 = class DatabricksSqlRunExecutor {
     adapterFactory;
     queryBuilder;
     type = data_storage_type_enum_1.DataStorageType.DATABRICKS;
+    logger = new common_1.Logger(DatabricksSqlRunExecutor_1.name);
     constructor(adapterFactory, queryBuilder) {
         this.adapterFactory = adapterFactory;
         this.queryBuilder = queryBuilder;
@@ -36,28 +39,67 @@ let DatabricksSqlRunExecutor = class DatabricksSqlRunExecutor {
         if (!sql) {
             sql = this.queryBuilder.buildQuery(definition);
         }
+        let cursor = null;
+        let executionError = null;
+        let closeError = null;
         try {
-            const { rows } = await adapter.executeQuery(sql);
-            const columns = rows && rows.length > 0 ? Object.keys(rows[0]) : undefined;
-            if (!rows || rows.length === 0) {
-                yield new sql_run_batch_dto_1.SqlRunBatch([], null, columns ?? null);
-                return;
-            }
             const maxRowsPerBatch = options?.maxRowsPerBatch || 1000;
-            for (let i = 0; i < rows.length; i += maxRowsPerBatch) {
-                const batch = rows.slice(i, i + maxRowsPerBatch);
-                const isLast = i + maxRowsPerBatch >= rows.length;
-                const nextBatchId = isLast ? null : String(i + maxRowsPerBatch);
-                yield new sql_run_batch_dto_1.SqlRunBatch(batch, nextBatchId, columns);
+            cursor = await adapter.openQueryCursor(sql);
+            let rowsRead = 0;
+            let hasEmittedRows = false;
+            let columns = await cursor.getColumns();
+            let columnsResolvedFromRowData = false;
+            while (true) {
+                const rows = (await cursor.fetchChunk(maxRowsPerBatch));
+                if (!rows.length) {
+                    if (!hasEmittedRows) {
+                        yield new sql_run_batch_dto_1.SqlRunBatch([], null, columns ?? null);
+                    }
+                    break;
+                }
+                hasEmittedRows = true;
+                rowsRead += rows.length;
+                if (!columnsResolvedFromRowData) {
+                    columns = Object.keys(rows[0]);
+                    columnsResolvedFromRowData = true;
+                }
+                const hasMoreRows = await cursor.hasMoreRows();
+                const nextBatchId = hasMoreRows ? String(rowsRead) : null;
+                yield new sql_run_batch_dto_1.SqlRunBatch(rows, nextBatchId, columns);
+                if (!hasMoreRows) {
+                    break;
+                }
             }
         }
+        catch (error) {
+            executionError = (0, internal_helpers_1.castError)(error);
+        }
         finally {
-            await adapter.destroy();
+            try {
+                if (cursor) {
+                    await cursor.close();
+                }
+            }
+            catch (error) {
+                closeError = (0, internal_helpers_1.castError)(error);
+                if (executionError) {
+                    this.logger.warn(`Failed to close Databricks cursor after SQL run error: ${closeError.message}. Preserving original error: ${executionError.message}`);
+                }
+            }
+            finally {
+                await adapter.destroy();
+            }
+        }
+        if (executionError) {
+            throw executionError;
+        }
+        if (closeError) {
+            throw new Error(`Failed to close Databricks cursor after SQL run: ${closeError.message}`);
         }
     }
 };
 exports.DatabricksSqlRunExecutor = DatabricksSqlRunExecutor;
-exports.DatabricksSqlRunExecutor = DatabricksSqlRunExecutor = __decorate([
+exports.DatabricksSqlRunExecutor = DatabricksSqlRunExecutor = DatabricksSqlRunExecutor_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [databricks_api_adapter_factory_1.DatabricksApiAdapterFactory,
         databricks_query_builder_1.DatabricksQueryBuilder])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owox/backend",
-  "version": "0.23.0-next-20260410055152",
+  "version": "0.23.0-next-20260413072944",
   "description": "OWOX Data Marts Backend - Full-stack data orchestration platform",
   "author": "OWOX",
   "license": "ELv2",
@@ -78,9 +78,9 @@
     "@nestjs/schedule": "^6.0.0",
     "@nestjs/swagger": "^11.2.0",
     "@nestjs/typeorm": "^11.0.0",
-    "@owox/connectors": "0.23.0-next-20260410055152",
-    "@owox/idp-protocol": "0.23.0-next-20260410055152",
-    "@owox/internal-helpers": "0.23.0-next-20260410055152",
+    "@owox/connectors": "0.23.0-next-20260413072944",
+    "@owox/idp-protocol": "0.23.0-next-20260413072944",
+    "@owox/internal-helpers": "0.23.0-next-20260413072944",
     "better-sqlite3": "^12.2.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.2",
@@ -139,7 +139,7 @@
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "typeorm-ts-node-commonjs": "^0.3.20",
-    "@owox/test-utils": "2.0.0-next-20260410055152"
+    "@owox/test-utils": "2.0.0-next-20260413072944"
   },
   "jest": {
     "moduleFileExtensions": [