@esri/solution-deployer 6.0.2-alpha.23 → 6.0.2-alpha.250423

package/dist/esm/deploySolutionItems.js

@@ -1,853 +0,0 @@
-/** @license
- * Copyright 2018 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Manages deployment of items via the REST API.
- *
- * @module deployItems
- */
-import * as common from "@esri/solution-common";
-import { moduleMap } from "./module-map";
-const UNSUPPORTED = null;
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Deploys a set of items defined by templates.
- *
- * @param portalSharingUrl Server/sharing
- * @param storageItemId Id of storage item
- * @param templates A collection of AGO item templates
- * @param storageAuthentication Credentials for the organization with the source items
- * @param templateDictionary Hash of facts: org URL, adlib replacements
- * @param deployedSolutionId Id of deployed Solution item
- * @param destinationAuthentication Credentials for the destination organization
- * @param options Options to tune deployment
- * @returns A promise that will resolve with the list of information about the created items
- */
-export function deploySolutionItems(portalSharingUrl, storageItemId, templates, storageAuthentication, templateDictionary, deployedSolutionId, destinationAuthentication, options) {
-    return new Promise((resolve, reject) => {
-        // Prepare feedback mechanism
-        const totalEstimatedCost = _estimateDeploymentCost(templates) + 1; // solution items, plus avoid divide by 0
-        let percentDone = 10; // allow for previous deployment work
-        const progressPercentStep = (99 - percentDone) / totalEstimatedCost; // leave some % for caller for wrapup
-        const failedTemplateItemIds = [];
-        const deployedItemIds = [];
-        let statusOK = true;
-        // TODO: move to separate fn
-        const itemProgressCallback = (itemId, status, costUsed, createdItemId) => {
-            percentDone += progressPercentStep * costUsed;
-            /* istanbul ignore else */
-            if (options.progressCallback) {
-                if (status === common.EItemProgressStatus.Finished) {
-                    const event = {
-                        event: common.SItemProgressStatus[status],
-                        data: itemId,
-                    };
-                    options.progressCallback(Math.round(percentDone), options.jobId, event);
-                }
-                else {
-                    options.progressCallback(Math.round(percentDone), options.jobId);
-                }
-            }
-            /* istanbul ignore if */
-            if (options.consoleProgress) {
-                console.log(Date.now(), itemId, options.jobId ?? "", common.SItemProgressStatus[status], percentDone.toFixed(0) + "%", costUsed, createdItemId ? "==> " + createdItemId : "");
-            }
-            if (status === common.EItemProgressStatus.Created) {
-                deployedItemIds.push(createdItemId);
-            }
-            else if (status === common.EItemProgressStatus.Failed) {
-                failedTemplateItemIds.push(itemId);
-                console.error("Item " + itemId + " has failed");
-                statusOK = false;
-            }
-            return statusOK;
-            // ---------------------------------------------------------------------------------------------------------------
-        };
-        // portal does not allow views of a single source to be created at the same time
-        if (common.getProp(templateDictionary, "organization.isPortal")) {
-            templates = _evaluateSharedViewSources(templates);
-        }
-        // Create an ordered graph of the templates so that dependencies are created before the items that need them.
-        // Because cycles are permitted, we also keep track of items that need to be patched later because their
-        // dependencies are necessarily created after they are created.
-        const { buildOrder, itemsToBePatched } = common.topologicallySortItems(templates);
-        // For each item in order from no dependencies to dependent on other items,
-        //   * replace template symbols using template dictionary
-        //   * create item in destination group
-        //   * add created item's id into the template dictionary
-        const awaitAllItems = [];
-        const reuseItemsDef = _reuseDeployedItems(templates, options.enableItemReuse ?? false, templateDictionary, destinationAuthentication);
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        reuseItemsDef.then(() => {
-            const useExistingItemsDef = _useExistingItems(templates, common.getProp(templateDictionary, "params.useExisting"), templateDictionary, destinationAuthentication);
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            useExistingItemsDef.then(() => {
-                templates = common.setNamesAndTitles(templates);
-                buildOrder.forEach((id) => {
-                    // Get the item's template out of the list of templates
-                    const template = common.findTemplateInList(templates, id);
-                    if (template.type === "Form") {
-                        // Flag all forms for post processing of their webhooks
-                        itemsToBePatched[id] = [];
-                    }
-                    else if (template.type === "QuickCapture Project") {
-                        // Remove qc.project.json files from the resources--we don't use them from solutions
-                        template.resources = template.resources.filter((filename) => !filename.endsWith("qc.project.json"));
-                    }
-                    awaitAllItems.push(_createItemFromTemplateWhenReady(template, common.generateStorageFilePaths(portalSharingUrl, storageItemId, template.resources, options.storageVersion), storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback));
-                });
-                // Wait until all items have been created
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.all(awaitAllItems).then((clonedSolutionItems) => {
-                    if (failedTemplateItemIds.length === 0) {
-                        // Do we have any items to be patched (i.e., they refer to dependencies using the template id rather
-                        // than the cloned id because the item had to be created before the dependency)? Flag these items
-                        // for post processing in the list of clones.
-                        _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, clonedSolutionItems);
-                        resolve(clonedSolutionItems);
-                    }
-                    else {
-                        // Delete created items
-                        const progressOptions = {
-                            consoleProgress: true,
-                        };
-                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        common
-                            .deleteSolutionByComponents(deployedSolutionId, deployedItemIds, templates, templateDictionary, destinationAuthentication, progressOptions)
-                            .then(() => reject(common.failWithIds(failedTemplateItemIds)));
-                    }
-                });
-            });
-        }, (e) => {
-            console.error(e);
-            reject(common.fail(e));
-        });
-    });
-}
-/**
- * For each item to be patched, convert it to its cloned id and mark the item as needing post processing.
- *
- * @param itemsToBePatched List of items that need to have their dependencies patched
- * @param templateDictionary Hash of facts: org URL, adlib replacements
- * @param templates A collection of AGO item templates
- * @private
- */
-export function _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, templates) {
-    let itemIdsToBePatched = Object.keys(itemsToBePatched);
-    /* istanbul ignore else */
-    if (itemIdsToBePatched.length > 0) {
-        // Replace the ids of the items to be patched (which are template ids) with their cloned versions
-        itemIdsToBePatched = itemIdsToBePatched.map((id) => templateDictionary[id].itemId);
-        // Make sure that the items to be patched are flagged for post processing
-        templates.forEach((item) => {
-            /* istanbul ignore else */
-            if (itemIdsToBePatched.includes(item.id)) {
-                item.postProcess = true;
-            }
-        });
-    }
-}
-/**
- * Portal does not allow views of a single source to be created at the same time.
- *
- * Update view templates with an array of other view template ids that it should wait on.
- *
- * @param templates a collection of AGO item templates
- *
- * @returns An updated array of item templates
- * @private
- */
-export function _evaluateSharedViewSources(templates) {
-    // update the templates so we can defer the deployment when more than one view shares the same source
-    // these are not classic dependencies but are in some ways similar
-    const views = _getViews(templates);
-    _updateViewTemplates(templates, views);
-    const viewHash = _getViewHash(views);
-    let processed = [];
-    const visited = [];
-    Object.keys(viewHash).forEach((k) => {
-        const _views = viewHash[k];
-        _views.forEach((cv) => {
-            const template = common.findTemplateInList(templates, cv);
-            const syncViews = common.getProp(template, "properties.syncViews");
-            /* istanbul ignore else */
-            if (visited.indexOf(template.itemId) > -1) {
-                processed = processed.concat(syncViews);
-            }
-            /* istanbul ignore else */
-            if (syncViews && syncViews.length > 0) {
-                // when a view has multiple dependencies we need to retain the syncViews if they have been set already...
-                common.setProp(template, "properties.syncViews", common.cloneObject(processed));
-            }
-            /* istanbul ignore else */
-            if (processed.indexOf(cv) < 0) {
-                processed.push(cv);
-            }
-            /* istanbul ignore else */
-            if (visited.indexOf(template.itemId) < 0) {
-                visited.push(template.itemId);
-            }
-        });
-        processed = [];
-    });
-    return templates;
-}
-/**
- * Add a syncViews array to each template that will hold all other view ids that
- * have the same FS dependency.
- * These arrays will be processed later to only contain ids that each view will need to wait on.
- *
- * @param templates a collection of AGO item templates
- * @param views an array of view template details
- *
- * @returns An updated array of item templates
- * @private
- */
-export function _updateViewTemplates(templates, views) {
-    views.forEach((v) => {
-        v.dependencies.forEach((id) => {
-            templates = templates.map((t) => {
-                /* istanbul ignore else */
-                if (common.getProp(t, "properties.service.isView") && t.dependencies.indexOf(id) > -1 && t.itemId !== v.id) {
-                    /* istanbul ignore else */
-                    if (!Array.isArray(t.properties.syncViews)) {
-                        t.properties.syncViews = [];
-                    }
-                    /* istanbul ignore else */
-                    if (t.properties.syncViews.indexOf(v.id) < 0) {
-                        t.properties.syncViews.push(v.id);
-                    }
-                }
-                return t;
-            });
-        });
-    });
-    return templates;
-}
-/**
- * Get all view templates from the source templates collection
- *
- * @param views A collection of view ID and dependencies
- *
- * @returns an array of objects with the source FS id as the key and a list of views that are
- * dependant upon it
- *
- * @private
- */
-export function _getViewHash(views) {
-    const viewHash = {};
-    views.forEach((v) => {
-        v.dependencies.forEach((d) => {
-            /* istanbul ignore else */
-            if (Object.keys(viewHash).indexOf(d) < 0) {
-                viewHash[d] = [v.id];
-            }
-            else if (viewHash[d].indexOf(v.id) < 0) {
-                viewHash[d].push(v.id);
-            }
-        });
-    });
-    return viewHash;
-}
-/**
- * Get all view templates from the source templates collection
- *
- * @param templates A collection of AGO item templates
- *
- * @returns an array with the view id and its dependencies
- *
- * @private
- */
-export function _getViews(templates) {
-    return templates.reduce((acc, v) => {
-        /* istanbul ignore else */
-        if (common.getProp(v, "properties.service.isView")) {
-            acc.push({
-                id: v.itemId,
-                dependencies: v.dependencies,
-            });
-        }
-        return acc;
-    }, []);
-}
-/**
- * Search for existing items and update the templateDictionary with key details
- *
- * @param templates A collection of AGO item templates
- * @param reuseItems Option to search for existing items
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param authentication Credentials for the requests
- *
- * @returns A Promise that will resolve once existing items have been evaluated
- *
- * @private
- */
-export function _reuseDeployedItems(templates, reuseItems, templateDictionary, authentication) {
-    return new Promise((resolve, reject) => {
-        if (reuseItems) {
-            const findItemsByKeywordResponse = _findExistingItemByKeyword(templates, templateDictionary, authentication);
-            const existingItemsByKeyword = findItemsByKeywordResponse.existingItemsDefs;
-            const existingItemInfos = findItemsByKeywordResponse.existingItemInfos;
-            Promise.all(existingItemsByKeyword).then((existingItemsByKeywordResponse) => {
-                const findExistingItemsByTag = _handleExistingItems(existingItemsByKeywordResponse, existingItemInfos, templateDictionary, authentication, true);
-                const existingItemsByTag = findExistingItemsByTag.existingItemsDefs;
-                const existingItemInfosByTag = findExistingItemsByTag.existingItemInfos;
-                Promise.all(existingItemsByTag).then((existingItemsByTagResponse) => {
-                    _handleExistingItems(existingItemsByTagResponse, existingItemInfosByTag, templateDictionary, authentication, false);
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    _updateTemplateDictionary(templates, templateDictionary, authentication).then(resolve);
-                }, (e) => reject(common.fail(e)));
-            }, (e) => reject(common.fail(e)));
-        }
-        else {
-            resolve(null);
-        }
-    });
-}
-/**
- * Search for existing items and update the templateDictionary with key details
- *
- * Subtle difference between _reuseDeployedItems and _useExistingItems
- * _reuseDeployedItems: will search all existing items based on specific type keywords
- *   that would have been added by a previous deployment
- * _useExistingItems: will search for an existing item that the user provided
- *   the item id for while configuring in the deployment app.
- *   This type of item would not necessarily have been laid down by a previous deployment and
- *   can thus not expect that it will have the type keywords
- *
- * @param templates A collection of AGO item templates
- * @param useExisting Option to search for existing items
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param authentication Credentials for the requests
- *
- * @returns A Promise that will resolve once existing items have been evaluated
- *
- * @private
- */
-export function _useExistingItems(templates, useExisting, templateDictionary, authentication) {
-    return new Promise((resolve) => {
-        if (useExisting) {
-            const itemDefs = [];
-            const sourceIdHash = {};
-            const itemIds = [];
-            Object.keys(templateDictionary.params).forEach((k) => {
-                const v = templateDictionary.params[k];
-                /* istanbul ignore else */
-                if (v.itemId && /[0-9A-F]{32}/i.test(k)) {
-                    _updateTemplateDictionaryById(templateDictionary, k, v.itemId, v);
-                    // need to check and set the typeKeyword if it doesn't exist on this service yet
-                    // when the user has passed in an itemId that does not come from a previous deployment
-                    itemDefs.push(common.getItemBase(v.itemId, authentication));
-                    sourceIdHash[v.itemId] = k;
-                    /* istanbul ignore else */
-                    if (itemIds.indexOf(k) < 0) {
-                        itemIds.push(k);
-                    }
-                }
-            });
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication).then(() => {
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                _updateTemplateDictionary(itemIds.map((id) => common.getTemplateById(templates, id)), templateDictionary, authentication).then(resolve);
-            });
-        }
-        else {
-            resolve(null);
-        }
-    });
-}
-/**
- * Verify if the existing item has the source-<itemId> typeKeyword and set it if not
- * This allows items that did not come from deployment to be found for reuse after they
- * have been used once via a custom itemId param
- *
- * @param itemDefs
- * @param sourceIdHash key value pairs..actual itemId is the key and the source itemId is the value
- * @param authentication credentials for the requests
- *
- * @returns a promise to indicate when the requests are complete
- * @private
- */
-export function _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication) {
-    return new Promise((resolve) => {
-        if (itemDefs.length > 0) {
-            Promise.all(itemDefs).then((results) => {
-                const itemUpdateDefs = [];
-                results.forEach((result) => {
-                    const sourceId = sourceIdHash[result.id];
-                    /* istanbul ignore else */
-                    if (result && sourceId && result.typeKeywords) {
-                        const sourceKeyword = `source-${sourceId}`;
-                        const typeKeywords = result.typeKeywords;
-                        /* istanbul ignore else */
-                        if (typeKeywords.indexOf(sourceKeyword) < 0) {
-                            typeKeywords.push(sourceKeyword);
-                            const itemUpdate = { id: result.id, typeKeywords };
-                            itemUpdateDefs.push(common.updateItem(itemUpdate, authentication));
-                        }
-                    }
-                });
-                // wait for updates to finish before we resolve
-                if (itemUpdateDefs.length > 0) {
-                    Promise.all(itemUpdateDefs).then(resolve, () => resolve(undefined));
-                }
-                else {
-                    resolve(undefined);
-                }
-            }, () => resolve(undefined));
-        }
-        else {
-            resolve(undefined);
-        }
-    });
-}
-/**
- * Update the templateDictionary with key details by item type
- *
- * @param templates A collection of AGO item templates
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- *
- * @private
- */
-export function _updateTemplateDictionary(templates, templateDictionary, authentication) {
-    return new Promise((resolve) => {
-        const defs = [];
-        const urls = [];
-        const types = [];
-        const ids = [];
-        templates.forEach((t) => {
-            const templateInfo = templateDictionary[t.itemId];
-            /* istanbul ignore else */
-            if (templateInfo && templateInfo.url && templateInfo.itemId) {
-                /* istanbul ignore else */
-                if (t.item.type === "Feature Service") {
-                    const enterpriseIDMapping = common.getProp(templateDictionary, `params.${t.itemId}.enterpriseIDMapping`);
-                    Object.assign(templateDictionary[t.itemId], common.getLayerSettings(common.getLayersAndTables(t), templateInfo.url, templateInfo.itemId, enterpriseIDMapping));
-                    // if the service has veiws keep track of the fields so we can use them to
-                    // compare with the view fields
-                    /* istanbul ignore else */
-                    if (common.getProp(t, "properties.service.hasViews")) {
-                        common._updateTemplateDictionaryFields(t, templateDictionary, false);
-                    }
-                }
-                // for fs query with its url...for non fs query the item
-                // this is to verify situations where we have a stale search index that will
-                // say some items exist when they don't really exist
-                // searching the services url or with the item id will return an error when this condition occurs
-                /* istanbul ignore else */
-                if (urls.indexOf(templateInfo.url) < 0) {
-                    defs.push(t.item.type === "Feature Service"
-                        ? common.request(templateInfo.url, { authentication })
-                        : common.getItemBase(templateInfo.itemId, authentication));
-                    urls.push(templateInfo.url);
-                    types.push(t.item.type);
-                    ids.push(templateInfo.itemId);
-                }
-            }
-        });
-        if (defs.length > 0) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            Promise.all(defs.map((p) => p.catch((e) => e))).then((results) => {
-                /* istanbul ignore else */
-                if (Array.isArray(results) && results.length > 0) {
-                    const fieldDefs = [];
-                    results.forEach((r, i) => {
-                        // a feature service result will contain a serviceItemId if it was successfully fetched
-                        if (r.serviceItemId && types[i] === "Feature Service") {
-                            Object.keys(templateDictionary).forEach((k) => {
-                                const v = templateDictionary[k];
-                                /* istanbul ignore else */
-                                if (v.itemId && v.itemId === r.serviceItemId) {
-                                    common.setDefaultSpatialReference(templateDictionary, k, r.spatialReference);
-                                    // keep the extent values from these responses as well
-                                    common.setCreateProp(templateDictionary, `${k}.defaultExtent`, r.fullExtent || r.initialExtent);
-                                    const layerIds = (r.layers || []).map((l) => l.id);
-                                    const tablesIds = (r.tables || []).map((t) => t.id);
-                                    fieldDefs.push(common.getExistingLayersAndTables(urls[i], layerIds.concat(tablesIds), authentication));
-                                }
-                            });
-                        }
-                        else {
-                            /* istanbul ignore else */
-                            if (types[i] === "Feature Service" || common.getProp(r, "response.error")) {
-                                // if an error is returned we need to clean up the templateDictionary
-                                templateDictionary = _updateTemplateDictionaryForError(templateDictionary, ids[i]);
-                            }
-                        }
-                    });
-                    if (fieldDefs.length > 0) {
-                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        Promise.all(fieldDefs).then((layerTableResult) => {
-                            layerTableResult.forEach((l) => {
-                                l.forEach((ll) => {
-                                    Object.keys(templateDictionary).forEach((k) => {
-                                        /* istanbul ignore else */
-                                        if (templateDictionary[k].itemId === ll.serviceItemId) {
-                                            let sourceId = "";
-                                            Object.keys(templateDictionary).some((_k) => {
-                                                /* istanbul ignore else */
-                                                if (templateDictionary[_k].itemId === ll.serviceItemId) {
-                                                    sourceId = _k;
-                                                    return true;
-                                                }
-                                            });
-                                            const enterpriseIDMapping = common.getProp(templateDictionary, `params.${sourceId}.enterpriseIDMapping`);
-                                            if (enterpriseIDMapping) {
-                                                Object.keys(enterpriseIDMapping).forEach((id) => {
-                                                    if (enterpriseIDMapping[id].toString() === ll.id.toString()) {
-                                                        _setFields(templateDictionary, k, id, ll.fields);
-                                                    }
-                                                });
-                                            }
-                                            else {
-                                                _setFields(templateDictionary, k, ll.id, ll.fields);
-                                            }
-                                        }
-                                    });
-                                });
-                            });
-                            resolve(null);
-                        });
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    resolve(null);
-                }
-            });
-        }
-        else {
-            resolve(null);
-        }
-    });
-}
-/**
- * Add the fields from the source layer to the template dictionary for any required replacements
- *
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param itemId the id for the item
- * @param layerId the id for the layer
- * @param fields the fields to transfer
- *
- * @private
- */
-export function _setFields(templateDictionary, itemId, layerId, fields) {
-    const layerInfo = common.getProp(templateDictionary, `${itemId}.layer${layerId}`);
-    /* istanbul ignore else */
-    if (layerInfo && fields) {
-        layerInfo.fields = fields;
-    }
-}
-/**
- * In some cases an item id search will return a stale item reference
- * it will subsequently fail when we try to fetch the underlying service.
- *
- * We need to remove the item info that has been added to the template dictionary
- * and treat the item as we do other items that don't already exist on deployment.
- *
- * @param result the service request result
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- *
- * @private
- */
-export function _updateTemplateDictionaryForError(templateDictionary, itemId) {
-    /* istanbul ignore else */
-    if (itemId) {
-        let removeKey = "";
-        Object.keys(templateDictionary).some((k) => {
-            /* istanbul ignore else */
-            if (templateDictionary[k].itemId === itemId) {
-                removeKey = k;
-                return true;
-            }
-        });
-        /* istanbul ignore else */
-        if (removeKey !== "") {
-            delete templateDictionary[removeKey];
-        }
-    }
-    return templateDictionary;
-}
-/**
- * Optionally search by tags and then update the templateDictionary based on the search results
- *
- * @param existingItemsResponse response object from search by typeKeyword and type
- * @param existingItemIds list of the template ids we have queried
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param authentication Credentials for the request
- * @param addTagQuery Boolean to indicate if a search by tag should happen
- * @returns IFindExistingItemsResponse object with  promise that will resolve with an array of results
- * and an array of item ids
- * @private
- */
-export function _handleExistingItems(existingItemsResponse, existingItemInfos, templateDictionary, authentication, addTagQuery) {
-    // if items are not found by type keyword search by tag
-    const existingItemsByTag = [Promise.resolve(null)];
-    const existingItemInfosByTag = [undefined];
-    /* istanbul ignore else */
-    if (existingItemsResponse && Array.isArray(existingItemsResponse)) {
-        existingItemsResponse.forEach((existingItem, i) => {
-            /* istanbul ignore else */
-            if (Array.isArray(existingItem?.results)) {
-                let result;
-                const results = existingItem.results;
-                if (results.length === 1) {
-                    result = results[0];
-                }
-                else if (results.length > 1) {
-                    result = results.reduce((a, b) => (a.created > b.created ? a : b));
-                }
-                else {
-                    if (addTagQuery && existingItemInfos[i]) {
-                        const itemInfo = existingItemInfos[i];
-                        const tagQuery = `tags:source-${itemInfo.itemId} type:${itemInfo.type} owner:${templateDictionary.user.username}`;
-                        existingItemsByTag.push(_findExistingItem(tagQuery, authentication));
-                        existingItemInfosByTag.push(existingItemInfos[i]);
-                    }
-                }
-                if (result) {
-                    const sourceId = existingItemInfos[i].itemId;
-                    /* istanbul ignore else */
-                    if (sourceId) {
-                        _updateTemplateDictionaryById(templateDictionary, sourceId, result.id, result);
-                    }
-                }
-            }
-        });
-    }
-    return {
-        existingItemsDefs: existingItemsByTag,
-        existingItemInfos: existingItemInfosByTag,
-    };
-}
-//TODO: function doc
-export function _updateTemplateDictionaryById(templateDictionary, sourceId, itemId, v) {
-    templateDictionary[sourceId] = Object.assign(templateDictionary[sourceId] || {}, {
-        def: Promise.resolve(common.generateEmptyCreationResponse(v.type, itemId)),
-        itemId,
-        name: v.name,
-        title: v.title,
-        url: v.url,
-        label: v.title,
-    });
-}
-/**
- * Search items based on user query
- *
- * @param templates Templates to examine
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param authentication Credentials for the request
- * @returns IFindExistingItemsResponse object with  promise that will resolve with an array of results
- * and an array of item ids
- * @private
- */
-export function _findExistingItemByKeyword(templates, templateDictionary, authentication) {
-    const existingItemsDefs = [];
-    const existingItemInfos = [];
-    templates.forEach((template) => {
-        if (template.item.type === "Group") {
-            const userGroups = templateDictionary.user?.groups;
-            /* istanbul ignore else */
-            if (Array.isArray(userGroups)) {
-                existingItemsDefs.push(Promise.resolve({
-                    results: userGroups
-                        .filter((g) => g.tags.indexOf(`source-${template.itemId}`) > -1 ||
-                        g.typeKeywords.indexOf(`source-${template.itemId}`) > -1)
-                        .map((g) => {
-                        g.type = "Group";
-                        return g;
-                    }),
-                    sourceId: template.itemId,
-                }));
-            }
-        }
-        else {
-            existingItemsDefs.push(_findExistingItem(`typekeywords:source-${template.itemId} type:${template.item.type} owner:${templateDictionary.user.username}`, authentication));
-        }
-        existingItemInfos.push({
-            itemId: template.itemId,
-            type: template.item.type,
-        });
-    });
-    return {
-        existingItemsDefs,
-        existingItemInfos,
-    };
-}
-/**
- * Search items based on user query
- *
- * @param query Query string to use
- * @param authentication Credentials for the request
- * @returns A promise that will resolve with an array of results
- * @private
- */
-export function _findExistingItem(query, authentication) {
-    const searchOptions = {
-        q: query,
-        authentication: authentication,
-        pagingParam: { start: 1, num: 100 },
-    };
-    return common.searchItems(searchOptions);
-}
-/**
- * Creates an item from a template once the item's dependencies have been created.
- *
- * @param template Template of item to deploy
- * @param resourceFilePaths URL, folder, and filename for each item resource/metadata/thumbnail
- * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
- * @param userSession Options for the request
- * @param itemProgressCallback Function for reporting progress updates from type-specific template handlers
- * @returns A promise that will resolve with the id of the deployed item (which is simply returned if it's
- *         already in the templates list
- * @private
- */
-export function _createItemFromTemplateWhenReady(template, resourceFilePaths, storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback) {
-    const sourceItemId = template.itemId;
-    // ensure this is present
-    template.dependencies = template.dependencies || [];
-    // if there is no entry in the templateDictionary
-    // or if we have a basic entry without the deferred request for its creation, add it
-    if (!templateDictionary.hasOwnProperty(template.itemId) ||
-        !common.getProp(templateDictionary[template.itemId], "def")) {
-        let createResponse;
-        let statusCode = common.EItemProgressStatus.Unknown;
-        let itemHandler;
-        templateDictionary[template.itemId] = templateDictionary[template.itemId] || {};
-        // Save the deferred for the use of items that depend on this item being created first
-        templateDictionary[template.itemId].def = new Promise((resolve) => {
-            // Wait until all of the item's dependencies are deployed
-            const _awaitDependencies = template.dependencies.reduce((acc, id) => {
-                const def = common.getProp(templateDictionary, `${id}.def`);
-                // can't use maybePush as that clones the object, which does not work for Promises
-                /* istanbul ignore else */
-                if (def) {
-                    acc.push(def);
-                }
-                return acc;
-            }, []);
-            const syncViews = common.getProp(template, "properties.syncViews");
-            const awaitDependencies = syncViews && syncViews.length > 0
-                ? syncViews.reduce((acc, v) => {
-                    const def = common.getProp(templateDictionary, `${v}.def`);
-                    /* istanbul ignore else */
-                    if (def) {
-                        acc.push(def);
-                    }
-                    return acc;
-                }, _awaitDependencies)
-                : _awaitDependencies;
-            Promise.all(awaitDependencies)
-                .then(() => {
-                // Find the conversion handler for this item type
-                const templateType = template.type;
-                itemHandler = moduleMap[templateType];
-                if (template.type === "Geoprocessing Service") {
-                    itemHandler = template.item.typeKeywords.indexOf("Web Tool") > -1 ? itemHandler : UNSUPPORTED;
-                }
-                if (!itemHandler || itemHandler === UNSUPPORTED) {
-                    if (itemHandler === UNSUPPORTED) {
-                        statusCode = common.EItemProgressStatus.Ignored;
-                        throw new Error();
-                    }
-                    else {
-                        statusCode = common.EItemProgressStatus.Failed;
-                        throw new Error();
-                    }
-                }
-                // Get the item's thumbnail
-                return common.getThumbnailFromStorageItem(storageAuthentication, resourceFilePaths);
-            })
-                .then((thumbnail) => {
-                template.item.thumbnail = thumbnail;
-                // Delegate the creation of the item to the handler
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                return itemHandler.createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
-            })
-                .then(async (response) => {
-                if (response.id === "") {
-                    statusCode = common.EItemProgressStatus.Failed;
-                    throw new Error("handled"); // fails to create item
-                }
-                /* istanbul ignore else */
-                createResponse = response;
-                if (createResponse.item.item.url) {
-                    common.setCreateProp(templateDictionary, sourceItemId + ".url", createResponse.item.item.url);
-                }
-                if (resourceFilePaths.length > 0) {
-                    const destinationItemId = createResponse.id;
-                    // Update and copy form resource
-                    if (template.type === "Form") {
-                        // Filter out Form zip file
-                        let formZipFilePath;
-                        resourceFilePaths = resourceFilePaths.filter((filePath) => {
-                            if (filePath.filename.endsWith(".zip")) {
-                                formZipFilePath = filePath;
-                                return false;
-                            }
-                            else {
-                                return true;
-                            }
-                        });
-                        if (formZipFilePath) {
-                            // Fetch the form's zip file and send it to the item
-                            const zipObject = await common.fetchZipObject(formZipFilePath.url, storageAuthentication);
-                            await common.updateItemWithZipObject(zipObject, destinationItemId, destinationAuthentication);
-                        }
-                    }
-                    // Copy resources, metadata
-                    return common.copyFilesFromStorageItem(storageAuthentication, resourceFilePaths, sourceItemId, templateDictionary.folderId, destinationItemId, destinationAuthentication, createResponse.item, templateDictionary);
-                }
-                else {
-                    return Promise.resolve(null);
-                }
-            })
-                .then(() => {
-                resolve(createResponse);
-            })
-                .catch((error) => {
-                if (!error || error.message !== "handled") {
-                    itemProgressCallback(sourceItemId, statusCode === common.EItemProgressStatus.Unknown ? common.EItemProgressStatus.Failed : statusCode, 0);
-                }
-                // Item type not supported or fails to get item dependencies
-                resolve(common.generateEmptyCreationResponse(template.type));
-            });
-        });
-    }
-    return templateDictionary[sourceItemId].def;
-}
-/**
- * Accumulates the estimated deployment cost of a set of templates.
- *
- * @param templates Templates to examine
- * @returns Sum of estimated deployment costs
- * @private
- */
-export function _estimateDeploymentCost(templates) {
-    return templates.reduce((accumulatedEstimatedCost, template) => {
-        return accumulatedEstimatedCost + (template.estimatedDeploymentCostFactor || 1);
-    }, 0);
-}
-//TODO: function doc
-// TODO: Return a Promise vs array of promises
-export function _getGroupUpdates(template, authentication, templateDictionary) {
-    const groups = template.groups || [];
-    return groups.map((sourceGroupId) => {
-        return common.shareItem(templateDictionary[sourceGroupId].itemId, template.itemId, authentication, common.isTrackingViewTemplate(template) ? templateDictionary.locationTracking.owner : undefined);
-    });
-}
-//# sourceMappingURL=deploySolutionItems.js.map