@azure/app-configuration-importer 2.0.0-preview → 3.0.1-preview

package/dist/index.js

@@ -527,7 +527,17 @@
     (function (ImportMode) {
         ImportMode[ImportMode["All"] = 0] = "All";
         ImportMode[ImportMode["IgnoreMatch"] = 1] = "IgnoreMatch";
-    })(exports.ImportMode || (exports.ImportMode = {}));
+    })(exports.ImportMode || (exports.ImportMode = {}));
+    /**
+     * Enums of change type for configuration settings changes
+     */
+    exports.ChangeType = void 0;
+    (function (ChangeType) {
+        ChangeType[ChangeType["None"] = 0] = "None";
+        ChangeType[ChangeType["Create"] = 1] = "Create";
+        ChangeType[ChangeType["Delete"] = 2] = "Delete";
+        ChangeType[ChangeType["Update"] = 3] = "Update";
+    })(exports.ChangeType || (exports.ChangeType = {}));
 
     function isFunction(value) {
         return typeof value === 'function';
@@ -19056,7 +19066,13 @@
                 }
             };
             const configurationChanges = await this.GetConfigurationChanges(configurationSettingsSource, options === null || options === void 0 ? void 0 : options.strict, options === null || options === void 0 ? void 0 : options.importMode, customHeadersOption);
-            return await this.applyUpdatesToServer([...configurationChanges.ToAdd, ...configurationChanges.ToModify, ...configurationChanges.ToRefresh], configurationChanges.ToDelete, options.timeout, customHeadersOption, options.progressCallback);
+            const settingsToWrite = configurationChanges
+                .filter(c => (c.changeType === exports.ChangeType.Create || c.changeType === exports.ChangeType.Update || c.changeType === exports.ChangeType.None) && c.newValue)
+                .map(c => c.newValue);
+            const settingsToDelete = configurationChanges
+                .filter(c => c.changeType === exports.ChangeType.Delete && c.currentValue)
+                .map(c => c.currentValue);
+            return await this.applyUpdatesToServer(settingsToWrite, settingsToDelete, options.timeout, customHeadersOption, options.progressCallback);
         }
         /**
          * Get configuration changes between source settings and existing settings in Azure App Configuration service without applying any changes
@@ -19077,10 +19093,11 @@
          *  'All' will include all key-values.
          *  'Ignore-Match' will exclude settings that have matching key-values in App Configuration.
          * @param customHeadersOption - Custom headers for the operation.
-         * @returns ConfigurationChanges object containing Added, Modified, and Deleted settings
+         * @returns Array of ConfigurationSettingChange objects representing the changes
          */
         async GetConfigurationChanges(configSettingsSource, strict = false, importMode = exports.ImportMode.IgnoreMatch, customHeadersOption) {
             var _a, e_1, _b, _c;
+            var _d, _e;
             this.validateImportMode(importMode);
             // Generate correlationRequestId for operations in the same activity
             if (!customHeadersOption) {
@@ -19100,60 +19117,70 @@
                 return configSettingsResult;
             }
             const configSettings = configSettingsResult;
-            const configurationSettingToDelete = [];
-            const configurationSettingToModify = [];
-            const configurationSettingToAdd = [];
-            const configurationSettingToRefresh = [];
-            const srcKeyLabelLookUp = {};
-            configSettings.forEach((config) => {
-                if (!srcKeyLabelLookUp[config.key]) {
-                    srcKeyLabelLookUp[config.key] = {};
-                }
-                srcKeyLabelLookUp[config.key][config.label || ""] = true;
-            });
-            configurationSettingToAdd.push(...configSettings);
+            const configurationChanges = [];
+            // Build O(1) lookup structures keyed by "key\0label" composite.
+            const srcMap = new Map();
+            const toAddKeys = new Set();
+            for (const config of configSettings) {
+                const composite = `${config.key}\u0000${(_d = config.label) !== null && _d !== void 0 ? _d : ""}`;
+                srcMap.set(composite, config);
+                toAddKeys.add(composite);
+            }
             try {
-                for (var _d = true, _e = __asyncValues(this.configurationClient.listConfigurationSettings(Object.assign(Object.assign({}, configSettingsSource.FilterOptions), customHeadersOption))), _f; _f = await _e.next(), _a = _f.done, !_a;) {
-                    _c = _f.value;
-                    _d = false;
+                // Stream target settings so we don't hold the entire remote store in memory.
+                for (var _f = true, _g = __asyncValues(this.configurationClient.listConfigurationSettings(Object.assign(Object.assign({}, configSettingsSource.FilterOptions), customHeadersOption))), _h; _h = await _g.next(), _a = _h.done, !_a;) {
+                    _c = _h.value;
+                    _f = false;
                     try {
                         const existing = _c;
-                        const isKeyLabelPresent = srcKeyLabelLookUp[existing.key] && srcKeyLabelLookUp[existing.key][existing.label || ""];
-                        if (strict && !isKeyLabelPresent) {
-                            configurationSettingToDelete.push(existing);
+                        const composite = `${existing.key}\u0000${(_e = existing.label) !== null && _e !== void 0 ? _e : ""}`;
+                        const incoming = srcMap.get(composite);
+                        if (strict && !incoming) {
+                            configurationChanges.push({
+                                changeType: exports.ChangeType.Delete,
+                                currentValue: existing,
+                                newValue: null
+                            });
                         }
-                        const incoming = configSettings.find(configSetting => configSetting.key == existing.key && configSetting.label === existing.label);
                         if (incoming) {
                             // Remove from add list since it already exists
-                            configurationSettingToAdd.splice(configurationSettingToAdd.indexOf(incoming), 1);
+                            toAddKeys.delete(composite);
                             if (!isConfigSettingEqual(incoming, existing)) {
-                                // Key-value has changed, add to ToModify
-                                configurationSettingToModify.push(incoming);
+                                configurationChanges.push({
+                                    changeType: exports.ChangeType.Update,
+                                    currentValue: existing,
+                                    newValue: incoming
+                                });
                             }
                             else if (importMode === exports.ImportMode.All) {
-                                // Key-value is unchanged and importMode is All, add to ToRefresh
-                                configurationSettingToRefresh.push(incoming);
+                                configurationChanges.push({
+                                    changeType: exports.ChangeType.None,
+                                    currentValue: existing,
+                                    newValue: incoming
+                                });
                             }
                         }
                     }
                     finally {
-                        _d = true;
+                        _f = true;
                     }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                    if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            return {
-                ToAdd: configurationSettingToAdd,
-                ToModify: configurationSettingToModify,
-                ToDelete: configurationSettingToDelete,
-                ToRefresh: configurationSettingToRefresh
-            };
+            for (const composite of toAddKeys) {
+                configurationChanges.push({
+                    changeType: exports.ChangeType.Create,
+                    currentValue: null,
+                    newValue: srcMap.get(composite)
+                });
+            }
+            return configurationChanges;
         }
         async applyUpdatesToServer(settingsToPut, settingsToDelete, timeout, options, progressCallback) {
             const deleteTaskManager = this.newAdaptiveTaskManager((setting) => this.configurationClient.deleteConfigurationSetting(setting, options), settingsToDelete);
@@ -19198,14 +19225,16 @@
          * @internal
          */
         isConfigurationChanges(obj) {
-            if (obj === null || typeof obj !== "object") {
+            if (!Array.isArray(obj)) {
                 return false;
             }
-            const configChanges = obj;
-            return Array.isArray(configChanges.ToAdd) &&
-                Array.isArray(configChanges.ToModify) &&
-                Array.isArray(configChanges.ToDelete) &&
-                Array.isArray(configChanges.ToRefresh);
+            // Validate it's an array of ConfigurationSettingChange objects
+            return obj.every(item => item &&
+                typeof item === "object" &&
+                "changeType" in item &&
+                "currentValue" in item &&
+                "newValue" in item &&
+                Object.values(exports.ChangeType).includes(item.changeType));
         }
     }