@esri/hub-common 9.40.0 → 9.41.0

package/dist/types/users/HubUsers.d.ts

@@ -0,0 +1,11 @@
+import { IUser } from "@esri/arcgis-rest-types";
+import { IHubSearchResult } from "../search";
+import { IHubRequestOptions } from "../types";
+/**
+ * Enrich a User object
+ * @param user
+ * @param includes
+ * @param requestOptions
+ * @returns
+ */
+export declare function enrichUserSearchResult(user: IUser, include: string[], requestOptions: IHubRequestOptions): Promise<IHubSearchResult>;

package/dist/types/users/_internal/enrichments.d.ts

@@ -0,0 +1,28 @@
+import { IUser, IPortal } from "@esri/arcgis-rest-portal";
+import { IEnrichmentErrorInfo, IHubRequestOptions } from "../../types";
+/**
+ * Possible additional properties available through enrichments
+ */
+export interface IUserEnrichments {
+    org?: IPortal;
+    /**
+     * Any errors encountered when fetching enrichments
+     * see https://github.com/ArcGIS/hub-indexer/blob/master/docs/errors.md#response-formatting-for-errors
+     */
+    errors?: IEnrichmentErrorInfo[];
+}
+export declare type UserEnrichment = keyof IUserEnrichments;
+/**
+ * Merging of the Enrichment and the User
+ */
+export interface IUserAndEnrichments extends IUserEnrichments {
+    user: IUser;
+}
+/**
+ * Fetch enrichments for Users
+ * @param group
+ * @param enrichments
+ * @param requestOptions
+ * @returns
+ */
+export declare function fetchUserEnrichments(user: IUser, enrichments: UserEnrichment[], requestOptions?: IHubRequestOptions): Promise<IUserAndEnrichments>;

package/dist/types/users/index.d.ts

@@ -0,0 +1 @@
+export * from "./HubUsers";

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.39.0 - Fri Jun 10 2022 17:25:47 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.40.0 - Fri Jun 10 2022 19:52:59 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -5444,6 +5444,17 @@
         return portalUrl + "/home/group.html?id=" + groupId;
     }
 
+    /**
+     * Return the URL of the user's page in the Portal Home application
+     * @param username The username
+     * @param portalUrlOrObject a portal base or API URL, a portal object, or request options containing either of those
+     * @returns URL to the user's profile, defaults to `https://www.arcgis.com/home/user.html?user={username}`
+     */
+    function getUserHomeUrl(username, portalUrlOrObject) {
+        var portalUrl = getPortalUrl(portalUrlOrObject);
+        return portalUrl + "/home/user.html?user=" + username;
+    }
+
     var MAP_OR_FEATURE_SERVER_URL_REGEX = /\/(map|feature)server/i;
     /**
      *
@@ -10032,7 +10043,7 @@
                 requestOptions: requestOptions,
             };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); });
     };
     var enrichMetadata = function (input) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
@@ -10064,7 +10075,7 @@
                 requestOptions: requestOptions,
             };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); });
     };
     // Note, this MUST be run after `enrichOwnerUser` to access the correct orgId during
     // processing. `item.orgId` is only SOMETIMES returned by Portal, so we need to have
@@ -10082,7 +10093,7 @@
                 requestOptions: requestOptions,
             };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); });
     };
     var enrichData = function (input) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
@@ -10092,7 +10103,7 @@
             stack.finish(opId);
             return { data: __assign(__assign({}, data), { data: itemData }), stack: stack, requestOptions: requestOptions };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); });
     };
     var enrichServer = function (input) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
@@ -10104,7 +10115,7 @@
             stack.finish(opId);
             return { data: __assign(__assign({}, data), { server: server }), stack: stack, requestOptions: requestOptions };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); });
     };
     var enrichLayers = function (input) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
@@ -10122,12 +10133,12 @@
             stack.finish(opId);
             return { data: __assign(__assign({}, data), { layers: layers }), stack: stack, requestOptions: requestOptions };
         })
-            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); }));
+            .catch(function (error) { return handleEnrichmentError$2(error, input, opId); }));
     };
     // add the error to the content.errors,
     // log current stack operation as finished with an error
     // and return output that can be piped into the next operation
-    var handleEnrichmentError$1 = function (error, input, opId) {
+    var handleEnrichmentError$2 = function (error, input, opId) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
         stack.finish(opId, { error: error });
         return {
@@ -13222,7 +13233,7 @@
                 requestOptions: requestOptions,
             };
         })
-            .catch(function (error) { return handleEnrichmentError(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
     };
     /**
      * Create a summary of the Group membership by searching for members,
@@ -13247,12 +13258,12 @@
                 requestOptions: requestOptions,
             };
         })
-            .catch(function (error) { return handleEnrichmentError(error, input, opId); });
+            .catch(function (error) { return handleEnrichmentError$1(error, input, opId); });
     };
     // add the error to the content.errors,
     // log current stack operation as finished with an error
     // and return output that can be piped into the next operation
-    var handleEnrichmentError = function (error, input, opId) {
+    var handleEnrichmentError$1 = function (error, input, opId) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
         stack.finish(opId, { error: error });
         return {
@@ -13264,7 +13275,7 @@
     /**
      * Available enrichments for Groups
      */
-    var groupEnrichementOperations = {
+    var groupEnrichementOperations$1 = {
         membershipSummary: enrichGroupMembershipSummary,
         contentCount: enrichGroupContentCount,
     };
@@ -13278,7 +13289,7 @@
     function fetchGroupEnrichments(group, enrichments, requestOptions) {
         // create a pipeline of enrichment operations
         var operations = enrichments.reduce(function (ops, enrichment) {
-            var operation = groupEnrichementOperations[enrichment];
+            var operation = groupEnrichementOperations$1[enrichment];
             // only include the enrichments that we know how to fetch
             operation && ops.push(operation);
             return ops;
@@ -14494,7 +14505,7 @@
                         so_1.countFields = options.aggFields.join(",");
                         so_1.countSize = options.aggLimit || 10;
                     }
-                    searchPromise = searchPortal$2(so_1);
+                    searchPromise = searchPortal$3(so_1);
                 }
                 else {
                     // Hub API Search
@@ -14522,7 +14533,7 @@
      * @param site
      * @returns
      */
-    function searchPortal$2(searchOptions) {
+    function searchPortal$3(searchOptions) {
         var _a;
         var portalUrl = ((_a = searchOptions.authentication) === null || _a === void 0 ? void 0 : _a.portal) || searchOptions.portal;
         var token;
@@ -14553,7 +14564,7 @@
                 results: content,
                 facets: facets,
                 hasNext: hasNext,
-                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$2),
+                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$3),
             };
         });
     }
@@ -17803,7 +17814,7 @@
                     so.countFields = options.aggFields.join(",");
                     so.countSize = options.aggLimit || 10;
                 }
-                return [2 /*return*/, searchPortal$1(so)];
+                return [2 /*return*/, searchPortal$2(so)];
             });
         });
     }
@@ -17814,7 +17825,7 @@
      * @param searchOptions
      * @returns
      */
-    function searchPortal$1(searchOptions) {
+    function searchPortal$2(searchOptions) {
         return __awaiter(this, void 0, void 0, function () {
             var resp, fn, results, facets;
             return __generator(this, function (_a) {
@@ -17835,7 +17846,7 @@
                                 results: results,
                                 facets: facets,
                                 hasNext: resp.nextStart > -1,
-                                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$1),
+                                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$2),
                             }];
                 }
             });
@@ -18123,7 +18134,7 @@
                 if (!so.authentication) {
                     so.portal = so.requestOptions.portal || api.url + "/sharing/rest";
                 }
-                return [2 /*return*/, searchPortal(so)];
+                return [2 /*return*/, searchPortal$1(so)];
             });
         });
     }
@@ -18134,7 +18145,7 @@
      * @param searchOptions
      * @returns
      */
-    function searchPortal(searchOptions) {
+    function searchPortal$1(searchOptions) {
         return __awaiter(this, void 0, void 0, function () {
             var resp, fn, results;
             return __generator(this, function (_a) {
@@ -18155,7 +18166,7 @@
                                 results: results,
                                 facets: [],
                                 hasNext: resp.nextStart > -1,
-                                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal),
+                                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$1),
                             }];
                 }
             });
@@ -18182,6 +18193,104 @@
         });
     }
 
+    /**
+     * @private
+     * Portal Search implementation for Users
+     * @param filterGroups
+     * @param options
+     */
+    function portalSearchUsers(filterGroups, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var expandedGroups, so, props;
+            return __generator(this, function (_a) {
+                // requestOptions is always required and user must be authd
+                if (!options.requestOptions) {
+                    throw new HubError$1("portalSearchUsers", "requestOptions: IHubRequestOptions is required.");
+                }
+                if (!options.requestOptions.authentication) {
+                    throw new HubError$1("portalSearchUsers", "requestOptions must pass authentication.");
+                }
+                expandedGroups = filterGroups.map(function (fg) {
+                    fg.filters = fg.filters.map(expandFilter);
+                    return fg;
+                });
+                so = serializeFilterGroupsForPortal(expandedGroups);
+                props = [
+                    "num",
+                    "sortField",
+                    "sortOrder",
+                    "include",
+                    "start",
+                    "requestOptions",
+                ];
+                // copy the props over
+                props.forEach(function (prop) {
+                    if (options.hasOwnProperty(prop)) {
+                        so[prop] = options[prop];
+                    }
+                });
+                // Ensure authentication gets sent
+                so.authentication = options.requestOptions.authentication;
+                // Execute search
+                return [2 /*return*/, searchPortal(so)];
+            });
+        });
+    }
+    /**
+     * Internal portal search, which then converts `IGroup`s to `IHubSearchResult`s
+     * handling enrichments & includes along the way
+     *
+     * @param searchOptions
+     * @returns
+     */
+    function searchPortal(searchOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resp, fn, results;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, searchUsers(searchOptions)];
+                    case 1:
+                        resp = _a.sent();
+                        fn = function (user) {
+                            return userToSearchResult(user, searchOptions.include, searchOptions.requestOptions);
+                        };
+                        return [4 /*yield*/, Promise.all(resp.results.map(fn))];
+                    case 2:
+                        results = _a.sent();
+                        // Group Search does not support aggregations
+                        // Construct the return
+                        return [2 /*return*/, {
+                                total: resp.total,
+                                results: results,
+                                facets: [],
+                                hasNext: resp.nextStart > -1,
+                                next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal),
+                            }];
+                }
+            });
+        });
+    }
+    /**
+     * Convert an Item to a IHubSearchResult
+     * Fetches the includes and attaches them to the item
+     * @param item
+     * @param includes
+     * @param requestOptions
+     * @returns
+     */
+    function userToSearchResult(user, includes, requestOptions) {
+        if (includes === void 0) { includes = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // Delegate to HubGroups module
+                // This layer of indirection is not necessary but
+                // aligns with how the items search works and
+                // allows for future specialization
+                return [2 /*return*/, enrichUserSearchResult(user, includes, requestOptions)];
+            });
+        });
+    }
+
     /**
      * Main Search function for ArcGIS Hub
      *
@@ -18215,6 +18324,7 @@
                     arcgis: {
                         item: portalSearchItems,
                         group: portalSearchGroups,
+                        user: portalSearchUsers,
                     },
                     "arcgis-hub": {
                         item: hubSearchItems,
@@ -18224,7 +18334,7 @@
                 if (!fn) {
                     throw new HubError$1("hubSearch", "Search via \"" + filterType + "\" filter against \"" + apiType + "\" api is not implemented");
                 }
-                return [2 /*return*/, fn(filterGroups, options)];
+                return [2 /*return*/, fn(cloneObject$1(filterGroups), options)];
             });
         });
     }
@@ -19698,6 +19808,145 @@
         return Hub;
     }());
 
+    var enrichUserOrg = function (input) {
+        var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
+        var opId = stack.start("enrichUserOrg");
+        var options = __assign(__assign({}, requestOptions), { 
+            // In order to get the correct response, we must pass options.portal
+            // as a base portal url (e.g., www.arcgis.com, qaext.arcgis.com, etc)
+            // **not** an org portal (i.e. org.maps.arcgis.com).
+            portal: getPortalBaseFromOrgUrl(requestOptions.portal) + "/sharing/rest" });
+        // TODO: Add Caching
+        // Had implemented a simple caching system, but it leads to unstable
+        // tests because we can't deterministically clear it
+        // if (!orgCache[data.user.orgId]) {
+        //   orgCache[data.user.orgId] = fetchOrg(data.user.orgId, options);
+        // }
+        // return (orgCache[data.user.orgId] as Promise<IPortal>)
+        return fetchOrg(data.user.orgId, options)
+            .then(function (results) {
+            stack.finish(opId);
+            return {
+                data: __assign(__assign({}, data), {
+                    org: results,
+                }),
+                stack: stack,
+                requestOptions: requestOptions,
+            };
+        })
+            .catch(function (error) { return handleEnrichmentError(error, input, opId); });
+    };
+    /**
+     * Simple cache for user org's. This does not expire
+     * but that seems reasonable as Org props rarely change
+     */
+    // This works find at run-time, but it's a problem in tests
+    // where we are validating calls. Will work with Randy to
+    // create something that's more robust
+    // const orgCache: Record<string, any> = {};
+    // add the error to the content.errors,
+    // log current stack operation as finished with an error
+    // and return output that can be piped into the next operation
+    var handleEnrichmentError = function (error, input, opId) {
+        var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
+        stack.finish(opId, { error: error });
+        return {
+            data: __assign(__assign({}, data), { errors: getEnrichmentErrors(error, data.errors) }),
+            stack: stack,
+            requestOptions: requestOptions,
+        };
+    };
+    /**
+     * Available enrichments for Groups
+     */
+    var groupEnrichementOperations = {
+        org: enrichUserOrg,
+    };
+    /**
+     * Fetch enrichments for Users
+     * @param group
+     * @param enrichments
+     * @param requestOptions
+     * @returns
+     */
+    function fetchUserEnrichments(user, enrichments, requestOptions) {
+        // create a pipeline of enrichment operations
+        var operations = enrichments.reduce(function (ops, enrichment) {
+            var operation = groupEnrichementOperations[enrichment];
+            // only include the enrichments that we know how to fetch
+            operation && ops.push(operation);
+            return ops;
+        }, []);
+        var pipeline = createOperationPipeline(operations);
+        // execute pipeline and return the item and enrichments
+        return pipeline({
+            data: { user: user },
+            stack: new OperationStack$1(),
+            requestOptions: requestOptions,
+        }).then(function (output) {
+            // TODO: send telemetry so we have info on what enrichments are requested and possible errors
+            return output.data;
+        });
+    }
+
+    /**
+     * Enrich a User object
+     * @param user
+     * @param includes
+     * @param requestOptions
+     * @returns
+     */
+    function enrichUserSearchResult(user, include, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, DEFAULTS, specs, enrichments, enriched, token;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = {
+                            access: user.access,
+                            id: user.username,
+                            type: "User",
+                            name: user.fullName,
+                            owner: user.username,
+                            summary: user.description,
+                            createdDate: new Date(user.created),
+                            createdDateSource: "user.created",
+                            updatedDate: new Date(user.modified),
+                            updatedDateSource: "user.modified",
+                            family: "people",
+                            links: {
+                                self: "not-implemented",
+                                siteRelative: "not-implemented",
+                                thumbnail: "not-implemented",
+                            },
+                        };
+                        DEFAULTS = ["org.name AS orgName"];
+                        // merge includes
+                        include = __spreadArrays(DEFAULTS, include).filter(unique);
+                        specs = include.map(parseInclude);
+                        enrichments = mapBy("enrichment", specs).filter(unique);
+                        enriched = {};
+                        if (!enrichments.length) return [3 /*break*/, 2];
+                        return [4 /*yield*/, fetchUserEnrichments(user, enrichments, requestOptions)];
+                    case 1:
+                        enriched = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // map the enriched props onto the result
+                        specs.forEach(function (spec) {
+                            result[spec.prop] = getProp(enriched, spec.path);
+                        });
+                        token = requestOptions.authentication.token;
+                        // Handle links
+                        result.links.thumbnail = getUserThumbnailUrl(requestOptions.portal, user, token);
+                        result.links.self = getUserHomeUrl(result.id, requestOptions);
+                        result.links.siteRelative = "/people/" + result.id;
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    }
+
     exports.ArcGISContext = ArcGISContext;
     exports.ArcGISContextManager = ArcGISContextManager;
     exports.DEFAULT_THEME = DEFAULT_THEME;
@@ -19825,6 +20074,7 @@
     exports.enrichPageSearchResult = enrichPageSearchResult;
     exports.enrichProjectSearchResult = enrichProjectSearchResult;
     exports.enrichSiteSearchResult = enrichSiteSearchResult;
+    exports.enrichUserSearchResult = enrichUserSearchResult;
     exports.ensureProp = ensureProp;
     exports.ensureUniqueDomainName = ensureUniqueDomainName;
     exports.ensureUniqueString = ensureUniqueString;
@@ -19916,6 +20166,7 @@
     exports.getUniqueDomainNamePortal = getUniqueDomainNamePortal;
     exports.getUniqueItemTitle = getUniqueItemTitle;
     exports.getUniqueSlug = getUniqueSlug;
+    exports.getUserHomeUrl = getUserHomeUrl;
     exports.getUserThumbnailUrl = getUserThumbnailUrl;
     exports.getWithDefault = getWithDefault$1;
     exports.hasBasePriv = hasBasePriv;