auth0-deploy-cli 8.22.0 → 8.23.0

package/lib/tools/auth0/handlers/connections.js

@@ -38,22 +38,13 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processConnectionEnabledClients = exports.updateConnectionEnabledClients = exports.getConnectionEnabledClients = exports.addExcludedConnectionPropertiesToChanges = exports.schema = void 0;
 const dot_prop_1 = __importDefault(require("dot-prop"));
-const lodash_1 = __importDefault(require("lodash"));
+const lodash_1 = require("lodash");
 const auth0_1 = require("auth0");
 const default_1 = __importStar(require("./default"));
 const utils_1 = require("../../utils");
@@ -111,14 +102,13 @@ exports.schema = {
 // This use case is common because organizations may not want to expose sensitive connection details, but want to preserve them in the tenant.
 // exported only for unit testing purposes
 const addExcludedConnectionPropertiesToChanges = ({ proposedChanges, existingConnections, config, }) => {
-    var _a, _b;
     if (proposedChanges.update.length === 0)
         return proposedChanges;
-    //@ts-ignore because this expects a parameter to be passed
-    const excludedFields = ((_b = (_a = config()) === null || _a === void 0 ? void 0 : _a.EXCLUDED_PROPS) === null || _b === void 0 ? void 0 : _b.connections) || [];
+    // @ts-ignore because this expects a parameter to be passed
+    const excludedFields = config()?.EXCLUDED_PROPS?.connections || [];
     if (excludedFields.length === 0)
         return proposedChanges;
-    const existingConnectionsMap = lodash_1.default.keyBy(existingConnections, 'id');
+    const existingConnectionsMap = (0, lodash_1.keyBy)(existingConnections, 'id');
     const excludedOptions = excludedFields.filter(
     // Only include fields that pertain to options
     (excludedField) => excludedField.startsWith('options'));
@@ -133,9 +123,18 @@ const addExcludedConnectionPropertiesToChanges = ({ proposedChanges, existingCon
         }, {
             options: {},
         });
-        return Object.assign(Object.assign({}, proposedConnection), { options: Object.assign(Object.assign({}, proposedConnection.options), currentExcludedPropertyValues.options) });
+        return {
+            ...proposedConnection,
+            options: {
+                ...proposedConnection.options,
+                ...currentExcludedPropertyValues.options,
+            },
+        };
     });
-    return Object.assign(Object.assign({}, proposedChanges), { update: newProposedUpdates });
+    return {
+        ...proposedChanges,
+        update: newProposedUpdates,
+    };
 };
 exports.addExcludedConnectionPropertiesToChanges = addExcludedConnectionPropertiesToChanges;
 /**
@@ -144,32 +143,28 @@ exports.addExcludedConnectionPropertiesToChanges = addExcludedConnectionProperti
  * @param connectionId - The unique identifier of the connection to fetch enabled clients for
  * @returns A promise that resolves to an array of client IDs, or null if connectionId is empty or an error occurs
  */
-const getConnectionEnabledClients = (auth0Client, connectionId) => __awaiter(void 0, void 0, void 0, function* () {
+const getConnectionEnabledClients = async (auth0Client, connectionId) => {
     if (!connectionId)
         return null;
     try {
         const enabledClientsFormatted = [];
-        let from;
-        let hasMore = true;
-        while (hasMore) {
-            const response = yield auth0Client.connections.getEnabledClients(Object.assign({ id: connectionId, take: 50 }, (from && { from })));
-            const { clients: enabledClients, next } = (response === null || response === void 0 ? void 0 : response.data) || {};
-            if (enabledClients === null || enabledClients === void 0 ? void 0 : enabledClients.length) {
-                enabledClients.forEach((client) => {
-                    if (client === null || client === void 0 ? void 0 : client.client_id) {
+        let enabledClients = await auth0Client.connections.clients.get(connectionId);
+        do {
+            if (enabledClients && enabledClients.data?.length > 0) {
+                enabledClients.data.forEach((client) => {
+                    if (client?.client_id) {
                         enabledClientsFormatted.push(client.client_id);
                     }
                 });
             }
-            hasMore = !!next;
-            from = next;
-        }
+            enabledClients = await enabledClients.getNextPage();
+        } while (enabledClients.hasNextPage());
         return enabledClientsFormatted;
     }
     catch (error) {
         return null;
     }
-});
+};
 exports.getConnectionEnabledClients = getConnectionEnabledClients;
 /**
  * Updates the enabled clients for a specific Auth0 connection.
@@ -181,18 +176,16 @@ exports.getConnectionEnabledClients = getConnectionEnabledClients;
  * @returns Promise that resolves to true if the update was successful, false otherwise
  *
  */
-const updateConnectionEnabledClients = (auth0Client, typeName, connectionId, enabledClientIds) => __awaiter(void 0, void 0, void 0, function* () {
+const updateConnectionEnabledClients = async (auth0Client, typeName, connectionId, enabledClientIds) => {
     if (!connectionId || !Array.isArray(enabledClientIds) || !enabledClientIds.length)
         return false;
     const enabledClientUpdatePayloads = enabledClientIds.map((clientId) => ({
         client_id: clientId,
         status: true,
     }));
-    const payloadChunks = lodash_1.default.chunk(enabledClientUpdatePayloads, 50);
+    const payloadChunks = (0, lodash_1.chunk)(enabledClientUpdatePayloads, 50);
     try {
-        yield Promise.all(payloadChunks.map((payload) => auth0Client.connections.updateEnabledClients({
-            id: connectionId,
-        }, payload)));
+        await Promise.all(payloadChunks.map((payload) => auth0Client.connections.clients.update(connectionId, payload)));
         logger_1.default.debug(`Updated enabled clients for ${typeName}: ${connectionId}`);
         return true;
     }
@@ -200,7 +193,7 @@ const updateConnectionEnabledClients = (auth0Client, typeName, connectionId, ena
         logger_1.default.error(`Unable to update enabled clients for ${typeName}: ${connectionId}:`, error);
         return false;
     }
-});
+};
 exports.updateConnectionEnabledClients = updateConnectionEnabledClients;
 /**
  * This function processes enabled clients for create, update, and conflict operations.
@@ -213,60 +206,64 @@ exports.updateConnectionEnabledClients = updateConnectionEnabledClients;
  *
  * @returns A Promise that resolves when all enabled client updates are complete
  */
-const processConnectionEnabledClients = (auth0Client_1, typeName_1, changes_1, ...args_1) => __awaiter(void 0, [auth0Client_1, typeName_1, changes_1, ...args_1], void 0, function* (auth0Client, typeName, changes, delayMs = 2500 // Default delay is 2.5 seconds
-) {
+const processConnectionEnabledClients = async (auth0Client, typeName, changes, delayMs = 2500 // Default delay is 2.5 seconds
+) => {
     const { create, update, conflicts } = changes;
     let createWithId = [];
     if (create.length) {
-        yield (0, utils_1.sleep)(delayMs); // Wait for the configured duration before fetching new connections
-        createWithId = yield Promise.all(create.map((conn) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
+        await (0, utils_1.sleep)(delayMs); // Wait for the configured duration before fetching new connections
+        createWithId = await Promise.all(create.map(async (conn) => {
             let newConnections;
             if (typeName === 'database') {
-                const { data: { connections }, } = yield auth0Client.connections.getAll({
+                const { data: connections } = await auth0Client.connections.list({
                     name: conn.name,
                     take: 1,
-                    strategy: [auth0_1.GetConnectionsStrategyEnum.auth0],
-                    include_totals: true,
+                    strategy: [auth0_1.Management.ConnectionStrategyEnum.Auth0],
+                    include_fields: true,
                 });
                 newConnections = connections;
             }
             else {
-                const { data: { connections }, } = yield auth0Client.connections.getAll({
+                const { data: connections } = await auth0Client.connections.list({
                     name: conn.name,
                     take: 1,
-                    include_totals: true,
+                    include_fields: true,
                 });
                 newConnections = connections;
             }
             if (newConnections && newConnections.length) {
-                conn.id = (_a = newConnections[0]) === null || _a === void 0 ? void 0 : _a.id;
+                conn.id = newConnections[0]?.id;
             }
             else {
                 logger_1.default.warn(`Unable to find ID for newly created ${typeName} '${conn.name}' when updating enabled clients`);
             }
             return conn;
-        })));
+        }));
     }
     // Process enabled clients for each change type
     // Delete is handled by the `processChanges` method, removed connection completely
-    yield Promise.all([
+    await Promise.all([
         ...createWithId.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
         ...update.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
         ...conflicts.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
     ]);
-});
+};
 exports.processConnectionEnabledClients = processConnectionEnabledClients;
 class ConnectionsHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'connections', stripUpdateFields: ['strategy', 'name'], functions: {
+        super({
+            ...config,
+            type: 'connections',
+            stripUpdateFields: ['strategy', 'name'],
+            functions: {
                 // When `connections` is updated, it can result in `update`,`create` or `delete` action on SCIM.
                 // Because, `scim_configuration` is inside `connections`.
-                update: (requestParams, bodyParams) => __awaiter(this, void 0, void 0, function* () { return yield this.scimHandler.updateOverride(requestParams, bodyParams); }),
+                update: async (requestParams, bodyParams) => this.scimHandler.updateOverride(requestParams, bodyParams),
                 // When a new `connection` is created. We can perform only `create` option on SCIM.
                 // When a connection is `deleted`. `scim_configuration` is also deleted along with it; no action on SCIM is required.
-                create: (bodyParams) => __awaiter(this, void 0, void 0, function* () { return yield this.scimHandler.createOverride(bodyParams); }),
-            } }));
+                create: async (bodyParams) => this.scimHandler.createOverride(bodyParams),
+            },
+        });
         // @ts-ignore
         this.scimHandler = new scimHandler_1.default(this.config, this.client.connections, this.client.pool);
     }
@@ -276,104 +273,102 @@ class ConnectionsHandler extends default_1.default {
     getFormattedOptions(connection, clients) {
         try {
             return {
-                options: Object.assign(Object.assign({}, connection.options), { idpinitiated: Object.assign(Object.assign({}, connection.options.idpinitiated), { client_id: (0, utils_1.convertClientNameToId)(connection.options.idpinitiated.client_id, clients) }) }),
+                options: {
+                    ...connection.options,
+                    idpinitiated: {
+                        ...connection.options.idpinitiated,
+                        client_id: (0, utils_1.convertClientNameToId)(connection.options.idpinitiated.client_id, clients),
+                    },
+                },
             };
         }
         catch (e) {
             return {};
         }
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            const connections = yield (0, client_1.paginate)(this.client.connections.getAll, {
-                checkpoint: true,
-                include_totals: true,
-            });
-            // Filter out database connections as we have separate handler for it
-            const filteredConnections = connections.filter((c) => c.strategy !== 'auth0');
-            // If options option is empty for all connection, log the missing options scope.
-            const isOptionExists = filteredConnections.every((c) => c.options && Object.keys(c.options).length > 0);
-            if (!isOptionExists) {
-                logger_1.default.warn(`Insufficient scope the read:connections_options scope is required to get ${this.type} options.`);
-            }
-            this.existing = filteredConnections;
-            if (this.existing === null)
-                return [];
-            const connectionsWithEnabledClients = yield Promise.all(filteredConnections.map((con) => __awaiter(this, void 0, void 0, function* () {
-                const enabledClients = yield (0, exports.getConnectionEnabledClients)(this.client, con.id);
-                if (enabledClients && (enabledClients === null || enabledClients === void 0 ? void 0 : enabledClients.length)) {
-                    return Object.assign(Object.assign({}, con), { enabled_clients: enabledClients });
-                }
-                return con;
-            })));
-            this.existing = connectionsWithEnabledClients;
-            // Apply `scim_configuration` to all the relevant `SCIM` connections. This method mutates `this.existing`.
-            yield this.scimHandler.applyScimConfiguration(this.existing);
+    async getType() {
+        if (this.existing)
             return this.existing;
+        const connections = await (0, client_1.paginate)(this.client.connections.list, {
+            checkpoint: true,
         });
+        // Filter out database connections as we have separate handler for it
+        const filteredConnections = connections.filter((c) => c.strategy !== 'auth0');
+        // If options option is empty for all connection, log the missing options scope.
+        const isOptionExists = filteredConnections.every((c) => c.options && Object.keys(c.options).length > 0);
+        if (!isOptionExists) {
+            logger_1.default.warn(`Insufficient scope the read:connections_options scope is required to get ${this.type} options.`);
+        }
+        this.existing = filteredConnections;
+        if (this.existing === null)
+            return [];
+        const connectionsWithEnabledClients = await Promise.all(filteredConnections.map(async (con) => {
+            if (!con?.id)
+                return con;
+            const enabledClients = await (0, exports.getConnectionEnabledClients)(this.client, con.id);
+            if (enabledClients && enabledClients?.length) {
+                return { ...con, enabled_clients: enabledClients };
+            }
+            return con;
+        }));
+        this.existing = connectionsWithEnabledClients;
+        // Apply `scim_configuration` to all the relevant `SCIM` connections. This method mutates `this.existing`.
+        await this.scimHandler.applyScimConfiguration(this.existing);
+        return this.existing;
     }
-    calcChanges(assets) {
-        const _super = Object.create(null, {
-            calcChanges: { get: () => super.calcChanges }
+    async calcChanges(assets) {
+        const { connections } = assets;
+        // Do nothing if not set
+        if (!connections)
+            return {
+                del: [],
+                create: [],
+                update: [],
+                conflicts: [],
+            };
+        // Convert enabled_clients by name to the id
+        const clients = await (0, client_1.paginate)(this.client.clients.list, {
+            paginate: true,
+            include_totals: true,
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { connections } = assets;
-            // Do nothing if not set
-            if (!connections)
-                return {
-                    del: [],
-                    create: [],
-                    update: [],
-                    conflicts: [],
-                };
-            // Convert enabled_clients by name to the id
-            const clients = yield (0, client_1.paginate)(this.client.clients.getAll, {
-                paginate: true,
-                include_totals: true,
-            });
-            const existingConnections = yield (0, client_1.paginate)(this.client.connections.getAll, {
-                checkpoint: true,
-                include_totals: true,
-            });
-            // Prepare an id map. We'll use this map later to get the `strategy` and SCIM enable status of the connections.
-            yield this.scimHandler.createIdMap(existingConnections);
-            const formatted = connections.map((connection) => (Object.assign(Object.assign(Object.assign({}, connection), this.getFormattedOptions(connection, clients)), { enabled_clients: (0, utils_1.getEnabledClients)(assets, connection, existingConnections, clients) })));
-            const proposedChanges = yield _super.calcChanges.call(this, Object.assign(Object.assign({}, assets), { connections: formatted }));
-            const proposedChangesWithExcludedProperties = (0, exports.addExcludedConnectionPropertiesToChanges)({
-                proposedChanges,
-                existingConnections,
-                config: this.config,
-            });
-            return proposedChangesWithExcludedProperties;
+        const existingConnections = await (0, client_1.paginate)(this.client.connections.list, {
+            checkpoint: true,
+            include_totals: true,
         });
+        // Prepare an id map. We'll use this map later to get the `strategy` and SCIM enable status of the connections.
+        await this.scimHandler.createIdMap(existingConnections);
+        const formatted = connections.map((connection) => ({
+            ...connection,
+            ...this.getFormattedOptions(connection, clients),
+            enabled_clients: (0, utils_1.getEnabledClients)(assets, connection, existingConnections, clients),
+        }));
+        const proposedChanges = await super.calcChanges({ ...assets, connections: formatted });
+        const proposedChangesWithExcludedProperties = (0, exports.addExcludedConnectionPropertiesToChanges)({
+            proposedChanges,
+            existingConnections,
+            config: this.config,
+        });
+        return proposedChangesWithExcludedProperties;
     }
     // Run after clients are updated so we can convert all the enabled_clients names to id's
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { connections } = assets;
-            // Do nothing if not set
-            if (!connections)
-                return;
-            // If options option is empty for all connection, log the missing options scope.
-            const isOptionExists = connections.every((c) => c.options && Object.keys(c.options).length > 0);
-            if (!isOptionExists) {
-                logger_1.default.warn(`Insufficient scope the update:connections_options scope is required to update ${this.type} options.`);
-            }
-            const excludedConnections = (assets.exclude && assets.exclude.connections) || [];
-            const changes = yield this.calcChanges(assets);
-            yield _super.processChanges.call(this, assets, (0, utils_1.filterExcluded)(changes, excludedConnections));
-            // process enabled clients
-            yield (0, exports.processConnectionEnabledClients)(this.client, this.type, (0, utils_1.filterExcluded)(changes, excludedConnections));
-        });
+    async processChanges(assets) {
+        const { connections } = assets;
+        // Do nothing if not set
+        if (!connections)
+            return;
+        // If options option is empty for all connection, log the missing options scope.
+        const isOptionExists = connections.every((c) => c.options && Object.keys(c.options).length > 0);
+        if (!isOptionExists) {
+            logger_1.default.warn(`Insufficient scope the update:connections_options scope is required to update ${this.type} options.`);
+        }
+        const excludedConnections = (assets.exclude && assets.exclude.connections) || [];
+        const changes = await this.calcChanges(assets);
+        await super.processChanges(assets, (0, utils_1.filterExcluded)(changes, excludedConnections));
+        // process enabled clients
+        await (0, exports.processConnectionEnabledClients)(this.client, this.type, (0, utils_1.filterExcluded)(changes, excludedConnections));
     }
 }
 exports.default = ConnectionsHandler;
 __decorate([
     (0, default_1.order)('60')
 ], ConnectionsHandler.prototype, "processChanges", null);
-//# sourceMappingURL=connections.js.map

package/lib/tools/auth0/handlers/customDomains.d.ts

@@ -1,3 +1,4 @@
+import { Management } from 'auth0';
 import DefaultAPIHandler from './default';
 import { Asset, Assets } from '../../../types';
 export declare const schema: {
@@ -50,10 +51,12 @@ export declare const schema: {
         required: string[];
     };
 };
+type CustomDomain = Management.CustomDomain;
 export default class CustomDomainsHadnler extends DefaultAPIHandler {
-    existing: Asset[] | null;
+    existing: CustomDomain[] | null;
     constructor(config: DefaultAPIHandler);
     objString(item: Asset): string;
     getType(): Promise<Asset | null>;
     processChanges(assets: Assets): Promise<void>;
 }
+export {};

package/lib/tools/auth0/handlers/customDomains.js

@@ -38,15 +38,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -93,14 +84,20 @@ exports.schema = {
 };
 class CustomDomainsHadnler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'customDomains', id: 'custom_domain_id', identifiers: ['custom_domain_id', 'domain'], stripCreateFields: [
+        super({
+            ...config,
+            type: 'customDomains',
+            id: 'custom_domain_id',
+            identifiers: ['custom_domain_id', 'domain'],
+            stripCreateFields: [
                 'status',
                 'primary',
                 'verification',
                 'certificate',
                 'created_at',
                 'updated_at',
-            ], stripUpdateFields: [
+            ],
+            stripUpdateFields: [
                 'status',
                 'primary',
                 'verification',
@@ -110,58 +107,51 @@ class CustomDomainsHadnler extends default_1.default {
                 'certificate',
                 'created_at',
                 'updated_at',
-            ], functions: {
-                delete: (args) => this.client.customDomains.delete({ id: args.custom_domain_id }),
-                update: (args, data) => this.client.customDomains.update({ id: args.custom_domain_id }, data),
-            } }));
+            ],
+            functions: {
+                update: (args, data) => this.client.customDomains.update(args.custom_domain_id, data),
+            },
+        });
     }
     objString(item) {
         return super.objString(item.domain);
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.existing) {
-                    return this.existing;
-                }
-                const customDomains = yield (0, client_1.paginate)(this.client.customDomains.getAll, {
-                    checkpoint: true,
-                });
-                this.existing = customDomains;
-                return customDomains;
+    async getType() {
+        try {
+            if (this.existing) {
+                return this.existing;
             }
-            catch (err) {
-                if (err.statusCode === 403 &&
-                    err.message ===
-                        'The account is not allowed to perform this operation, please contact our support team') {
-                    return null;
-                }
-                throw err;
+            const customDomains = await (0, client_1.paginate)(this.client.customDomains.list, {
+                checkpoint: true,
+            });
+            this.existing = customDomains;
+            return customDomains;
+        }
+        catch (err) {
+            if (err.statusCode === 403 &&
+                err.message ===
+                    'The account is not allowed to perform this operation, please contact our support team') {
+                return null;
             }
-        });
+            throw err;
+        }
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { customDomains } = assets;
-            if (!customDomains)
-                return;
-            // Deprecation warnings for custom domains
-            if (customDomains.some((customDomain) => customDomain.primary != null)) {
-                logger_1.default.warn('The "primary" field is deprecated and may be removed in future versions for "customDomains"');
-            }
-            if (customDomains.some((customDomain) => 'verification_method' in customDomain)) {
-                logger_1.default.warn('The "verification_method" field is deprecated and may be removed in future versions for "customDomains"');
-            }
-            const changes = yield this.calcChanges(assets);
-            yield _super.processChanges.call(this, assets, changes);
-        });
+    async processChanges(assets) {
+        const { customDomains } = assets;
+        if (!customDomains)
+            return;
+        // Deprecation warnings for custom domains
+        if (customDomains.some((customDomain) => customDomain.primary != null)) {
+            logger_1.default.warn('The "primary" field is deprecated and may be removed in future versions for "customDomains"');
+        }
+        if (customDomains.some((customDomain) => 'verification_method' in customDomain)) {
+            logger_1.default.warn('The "verification_method" field is deprecated and may be removed in future versions for "customDomains"');
+        }
+        const changes = await this.calcChanges(assets);
+        await super.processChanges(assets, changes);
     }
 }
 exports.default = CustomDomainsHadnler;
 __decorate([
     (0, default_1.order)('50')
 ], CustomDomainsHadnler.prototype, "processChanges", null);
-//# sourceMappingURL=customDomains.js.map