@boostercloud/framework-provider-azure 2.10.1 → 2.12.0

package/dist/helpers/query-helper.d.ts

@@ -1,3 +1,3 @@
 import { CosmosClient } from '@azure/cosmos';
-import { BoosterConfig, FilterFor, ReadModelListResult, SortFor } from '@boostercloud/framework-types';
-export declare function search<TResult>(cosmosDb: CosmosClient, config: BoosterConfig, containerName: string, filters: FilterFor<unknown>, limit?: number | undefined, afterCursor?: Record<string, string> | undefined, paginatedVersion?: boolean, order?: SortFor<unknown>, projections?: string): Promise<Array<TResult> | ReadModelListResult<TResult>>;
+import { BoosterConfig, FilterFor, ProjectionFor, ReadModelListResult, SortFor } from '@boostercloud/framework-types';
+export declare function search<TResult>(cosmosDb: CosmosClient, config: BoosterConfig, containerName: string, filters: FilterFor<unknown>, limit?: number | undefined, afterCursor?: Record<string, string> | undefined, paginatedVersion?: boolean, order?: SortFor<unknown>, projections?: ProjectionFor<unknown> | string): Promise<Array<TResult> | ReadModelListResult<TResult>>;

package/dist/helpers/query-helper.js

@@ -6,7 +6,8 @@ const framework_common_helpers_1 = require("@boostercloud/framework-common-helpe
 async function search(cosmosDb, config, containerName, filters, limit, afterCursor, paginatedVersion = false, order, projections = '*') {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'query-helper#search');
     const filterExpression = buildFilterExpression(filters);
-    const queryDefinition = `SELECT ${projections} FROM c ${filterExpression !== '' ? `WHERE ${filterExpression}` : filterExpression}`;
+    const projectionsExpression = buildProjections(projections);
+    const queryDefinition = `SELECT ${projectionsExpression} FROM c ${filterExpression !== '' ? `WHERE ${filterExpression}` : filterExpression}`;
     const queryWithOrder = queryDefinition + buildOrderExpression(order);
     let finalQuery = queryWithOrder;
     if (paginatedVersion && limit) {
@@ -22,11 +23,12 @@ async function search(cosmosDb, config, containerName, filters, limit, afterCurs
         parameters: buildExpressionAttributeValues(filters),
     };
     logger.debug('Running search with the following params: \n', querySpec);
-    const { resources } = await cosmosDb
+    let { resources } = await cosmosDb
         .database(config.resourceNames.applicationStack)
         .container(containerName)
         .items.query(querySpec)
         .fetchAll();
+    resources = nestProperties(resources);
     if (paginatedVersion) {
         return {
             items: resources !== null && resources !== void 0 ? resources : [],
@@ -178,3 +180,164 @@ function toLocalSortFor(sortBy, parentKey = '', sortedList = []) {
     });
     return sortedList;
 }
+function buildProjections(projections = '*') {
+    if (typeof projections !== 'object') {
+        return projections;
+    }
+    // Helper function to convert dot notation to square-bracket notation
+    const toSquareBracketsNotation = (path) => {
+        return path
+            .split('.')
+            .map((part) => `["${part}"]`)
+            .join('');
+    };
+    // Group fields by the root property
+    const groupedFields = {};
+    Object.values(projections).forEach((field) => {
+        const root = field.split('.')[0];
+        if (!groupedFields[root]) {
+            groupedFields[root] = [];
+        }
+        groupedFields[root].push(field);
+    });
+    return Object.keys(groupedFields)
+        .map((root) => {
+        const fields = groupedFields[root];
+        if (root.endsWith('[]')) {
+            const arrayRoot = root.slice(0, -2);
+            const subFields = fields
+                .map((f) => f.replace(`${root}.`, ''))
+                .map(toSquareBracketsNotation)
+                .map((f) => `item${f}`)
+                .join(', ');
+            return `ARRAY(SELECT ${subFields} FROM item IN c["${arrayRoot}"]) AS ${arrayRoot}`;
+        }
+        else if (fields.length === 1 && !fields[0].includes('.')) {
+            // Simple field
+            return `c${toSquareBracketsNotation(fields[0])}`;
+        }
+        else {
+            // Nested object fields
+            const nestedFields = {};
+            fields.forEach((f) => {
+                const parts = f.split('.').slice(1);
+                if (parts.length > 0) {
+                    const nestedRoot = parts[0];
+                    if (!nestedFields[nestedRoot]) {
+                        nestedFields[nestedRoot] = [];
+                    }
+                    nestedFields[nestedRoot].push(parts.join('.'));
+                }
+            });
+            return Object.keys(nestedFields)
+                .map((nestedRoot) => {
+                const subFields = nestedFields[nestedRoot]
+                    .map((f) => `c${toSquareBracketsNotation(`${root}.${f}`)} AS "${root}.${f}"`)
+                    .join(', ');
+                if (nestedRoot.endsWith('[]')) {
+                    const arrayNestedRoot = nestedRoot.slice(0, -2);
+                    const subArrayFields = nestedFields[nestedRoot]
+                        .map((f) => {
+                        const subFieldParts = f.split('.').slice(1).join('.');
+                        return `item${toSquareBracketsNotation(subFieldParts)}`;
+                    })
+                        .join(', ');
+                    return `ARRAY(SELECT ${subArrayFields} FROM item IN c${toSquareBracketsNotation(`${root}.${arrayNestedRoot}`)}) AS "${root}.${arrayNestedRoot}"`;
+                }
+                return subFields;
+            })
+                .join(', ');
+        }
+    })
+        .join(', ');
+}
+/**
+ * Transforms the flat properties returned by Cosmos DB into a nested structure. For example, the following object:
+ *
+ * ```json
+ * {
+ *   "foo.bar": "baz",
+ *   "items": [{"qux.quux": "corge"}]
+ * }
+ * ```
+ *
+ * is transformed to this:
+ *
+ * ```json
+ * {
+ *   "foo": {
+ *     "bar": "baz"
+ *   },
+ *   "items": [
+ *     {
+ *       "qux": {
+ *           "quux": "corge"
+ *         }
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * @param {any} obj - The object to be nested.
+ * @returns {any} - The nested object.
+ */
+function nestProperties(obj) {
+    const result = {};
+    /**
+     * Sets a nested property on an object.
+     * @param {any} obj - The object on which to set the property.
+     * @param {string[]} path - The path to the property.
+     * @param {any} value - The value to set.
+     */
+    function setNestedProperty(obj, path, value) {
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            if (!current[path[i]]) {
+                current[path[i]] = {};
+            }
+            current = current[path[i]];
+        }
+        current[path[path.length - 1]] = value;
+    }
+    /**
+     * Processes an object, nesting its properties.
+     * @param {any} input - The object to process.
+     * @param {any} output - The object to output.
+     */
+    function processObject(input, output) {
+        for (const key in input) {
+            if (Object.prototype.hasOwnProperty.call(input, key)) {
+                const value = input[key];
+                const keys = key.split('.');
+                setNestedProperty(output, keys, value);
+            }
+        }
+    }
+    /**
+     * Processes an array, nesting its properties.
+     * @param {any[]} arr - The array to process.
+     * @returns {any[]} - The processed array.
+     */
+    function processArray(arr) {
+        return arr.map((item) => {
+            if (Array.isArray(item)) {
+                return processArray(item);
+            }
+            else if (item !== null && typeof item === 'object') {
+                const nestedItem = {};
+                processObject(item, nestedItem);
+                return nestedItem;
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    if (Array.isArray(obj)) {
+        return processArray(obj);
+    }
+    else if (obj !== null && typeof obj === 'object') {
+        processObject(obj, result);
+    }
+    return result;
+}

package/dist/library/searcher-adapter.d.ts

@@ -1,3 +1,3 @@
 import { CosmosClient } from '@azure/cosmos';
-import { BoosterConfig, FilterFor, ReadModelListResult, SortFor } from '@boostercloud/framework-types';
-export declare function searchReadModel(cosmosDb: CosmosClient, config: BoosterConfig, readModelName: string, filters: FilterFor<unknown>, sortBy?: SortFor<unknown>, limit?: number, afterCursor?: Record<string, string> | undefined, paginatedVersion?: boolean): Promise<Array<any> | ReadModelListResult<any>>;
+import { BoosterConfig, FilterFor, ProjectionFor, ReadModelListResult, SortFor } from '@boostercloud/framework-types';
+export declare function searchReadModel(cosmosDb: CosmosClient, config: BoosterConfig, readModelName: string, filters: FilterFor<unknown>, sortBy?: SortFor<unknown>, limit?: number, afterCursor?: Record<string, string> | undefined, paginatedVersion?: boolean, select?: ProjectionFor<unknown>): Promise<Array<any> | ReadModelListResult<any>>;

package/dist/library/searcher-adapter.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchReadModel = void 0;
 const queryHelper = require("../helpers/query-helper");
-async function searchReadModel(cosmosDb, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion = false) {
-    return await queryHelper.search(cosmosDb, config, config.resourceNames.forReadModel(readModelName), filters, limit, afterCursor, paginatedVersion, sortBy);
+async function searchReadModel(cosmosDb, config, readModelName, filters, sortBy, limit, afterCursor, paginatedVersion = false, select) {
+    return await queryHelper.search(cosmosDb, config, config.resourceNames.forReadModel(readModelName), filters, limit, afterCursor, paginatedVersion, sortBy, select);
 }
 exports.searchReadModel = searchReadModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boostercloud/framework-provider-azure",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "description": "Handle Booster's integration with Azure",
   "keywords": [
     "framework-provider-azure"
@@ -27,14 +27,14 @@
     "@azure/functions": "^1.2.2",
     "@azure/identity": "~2.1.0",
     "@azure/event-hubs": "5.11.1",
-    "@boostercloud/framework-common-helpers": "^2.10.1",
-    "@boostercloud/framework-types": "^2.10.1",
+    "@boostercloud/framework-common-helpers": "^2.12.0",
+    "@boostercloud/framework-types": "^2.12.0",
     "tslib": "^2.4.0",
     "@effect-ts/core": "^0.60.4",
     "@azure/web-pubsub": "~1.1.0"
   },
   "devDependencies": {
-    "@boostercloud/eslint-config": "^2.10.1",
+    "@boostercloud/eslint-config": "^2.12.0",
     "@types/chai": "4.2.18",
     "@types/chai-as-promised": "7.1.4",
     "@types/faker": "5.1.5",