auth0-deploy-cli 7.7.1 → 7.10.0

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

@@ -0,0 +1,40 @@
+import DefaultAPIHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            type: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+            sink: {
+                type: string;
+            };
+            filters: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export default class LogStreamsHandler extends DefaultAPIHandler {
+    existing: Asset[] | null;
+    constructor(config: DefaultAPIHandler);
+    objString(item: Asset): string;
+    getType(): Promise<Asset>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+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.schema = void 0;
+const default_1 = __importDefault(require("./default"));
+exports.schema = {
+    type: 'array',
+    items: {
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+            type: { type: 'string' },
+            name: { type: 'string' },
+            status: { type: 'string', enum: ['active', 'paused', 'suspended'] },
+            sink: { type: 'object' },
+            filters: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                },
+            },
+        },
+        required: ['name'],
+    },
+};
+class LogStreamsHandler extends default_1.default {
+    constructor(config) {
+        super(Object.assign(Object.assign({}, config), { type: 'logStreams', stripUpdateFields: ['type'], stripCreateFields: ['status', 'sink.awsPartnerEventSource'], sensitiveFieldsToObfuscate: ['sink.httpAuthorization'] }));
+    }
+    objString(item) {
+        return super.objString(item.name);
+    }
+    getType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.existing) {
+                return this.existing;
+            }
+            const logStreams = yield this.client.logStreams.getAll({ paginate: false });
+            const nonSuspendedLogStreams = logStreams.filter((logStream) => logStream.status !== 'suspended');
+            this.existing = nonSuspendedLogStreams;
+            return nonSuspendedLogStreams;
+        });
+    }
+    processChanges(assets) {
+        const _super = Object.create(null, {
+            processChanges: { get: () => super.processChanges }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { logStreams } = assets;
+            // Do nothing if not set
+            if (!logStreams)
+                return;
+            // Figure out what needs to be updated vs created
+            const changes = yield this.calcChanges(assets).then((changes) => {
+                return Object.assign(Object.assign({}, changes), { update: changes.update.map((update) => {
+                        if (update.type === 'eventbridge' || update.type === 'eventgrid') {
+                            delete update.sink;
+                        }
+                        return update;
+                    }) });
+            });
+            yield _super.processChanges.call(this, assets, changes);
+        });
+    }
+}
+exports.default = LogStreamsHandler;

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

@@ -0,0 +1,15 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    additionalProperties: {
+        type: string;
+    };
+};
+export default class MigrationsHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[] | {}>;
+    processChanges(assets: Assets): Promise<void>;
+    logUnavailableMigrations(ignoreUnavailableMigrations: boolean, ignoredMigrations: string[]): void;
+    removeUnavailableMigrations(migrations: Asset[]): Promise<Asset[]>;
+}

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

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'object',
     additionalProperties: { type: 'boolean' },

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

@@ -0,0 +1,51 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            display_name: {
+                type: string;
+            };
+            branding: {
+                type: string;
+            };
+            metadata: {
+                type: string;
+            };
+            connections: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        connection_id: {
+                            type: string;
+                        };
+                        assign_membership_on_login: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export default class OrganizationsHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(config: DefaultHandler);
+    deleteOrganization(org: any): Promise<void>;
+    deleteOrganizations(data: any): Promise<void>;
+    createOrganization(org: any): Promise<Asset>;
+    createOrganizations(creates: CalculatedChanges['create']): Promise<void>;
+    updateOrganization(org: any, organizations: any): Promise<{
+        id: any;
+    }>;
+    updateOrganizations(updates: CalculatedChanges['update'], orgs: Asset[]): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -45,7 +45,7 @@ exports.schema = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'array',
     items: {
@@ -237,7 +237,7 @@ class OrganizationsHandler extends default_1.default {
                 assets: organizations,
                 existing,
                 identifiers: ['id', 'name'],
-                allowDelete: false, //TODO: actually pass in correct allowDelete value
+                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
             });
             logger_1.default.debug(`Start processChanges for organizations [delete:${changes.del.length}] [update:${changes.update.length}], [create:${changes.create.length}]`);
             const myChanges = [

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

@@ -0,0 +1,42 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const supportedPages: string[];
+export declare const pageNameMap: {
+    guardian_multifactor: string;
+    password_reset: string;
+    error_page: string;
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                enum: string[];
+            };
+            html: {
+                type: string;
+                default: string;
+            };
+            url: {
+                type: string;
+            };
+            show_log_link: {
+                type: string;
+            };
+            enabled: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class PagesHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    objString(page: any): string;
+    updateLoginPage(page: any): Promise<void>;
+    updatePages(pages: Asset[]): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+};
+export default class PromptsHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,51 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            identifier: {
+                type: string;
+            };
+            scopes: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                        };
+                        description: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            enforce_policies: {
+                type: string;
+            };
+            token_dialect: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class ResourceServersHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    objString(resourceServer: any): string;
+    getType(): Promise<Asset[]>;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+    validate(assets: Assets): Promise<void>;
+}

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

@@ -83,7 +83,7 @@ class ResourceServersHandler extends default_1.default {
                 assets: resourceServers,
                 existing,
                 identifiers: ['id', 'identifier'],
-                allowDelete: false, //TODO: actually pass in correct allowDelete value
+                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
             });
         });
     }

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

@@ -0,0 +1,48 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            id: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            permissions: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        permission_name: {
+                            type: string;
+                        };
+                        resource_server_identifier: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+export default class RolesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(config: DefaultHandler);
+    createRole(data: any): Promise<Asset>;
+    createRoles(creates: CalculatedChanges['create']): Promise<void>;
+    deleteRole(data: any): Promise<void>;
+    deleteRoles(dels: CalculatedChanges['del']): Promise<void>;
+    updateRole(data: any, roles: any): Promise<{
+        id: any;
+    }>;
+    updateRoles(updates: CalculatedChanges['update'], roles: any): Promise<void>;
+    getType(): Promise<Asset[]>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -44,7 +44,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'array',
     items: {
@@ -210,7 +210,7 @@ class RolesHandler extends default_1.default {
                 assets: roles,
                 existing,
                 identifiers: ['id', 'name'],
-                allowDelete: false, //TODO: actually pass in correct allowDelete value
+                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
             });
             logger_1.default.debug(`Start processChanges for roles [delete:${changes.del.length}] [update:${changes.update.length}], [create:${changes.create.length}]`);
             const myChanges = [

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

@@ -0,0 +1,55 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        default: never[];
+        properties: {
+            script: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            name: {
+                type: string;
+                description: string;
+                pattern: string;
+            };
+            order: {
+                type: string[];
+                description: string;
+                default: null;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            stage: {
+                type: string;
+                description: string;
+                default: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class RulesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(rule: any): string;
+    calcChanges(assets: any, includeExcluded?: boolean): Promise<CalculatedChanges & {
+        reOrder: Asset[];
+    }>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -16,7 +16,7 @@ exports.schema = exports.excludeSchema = void 0;
 const validationError_1 = __importDefault(require("../../validationError"));
 const utils_1 = require("../../utils");
 const default_1 = __importDefault(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 const calculateChanges_1 = require("../../calculateChanges");
 exports.excludeSchema = {
     type: 'array',
@@ -89,7 +89,7 @@ class RulesHandler extends default_1.default {
                 assets: rules,
                 existing,
                 identifiers: ['id', 'name'],
-                allowDelete: false, //TODO: actually pass in correct allowDelete value
+                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
             });
             // Figure out the rules that need to be re-ordered
             const futureRules = [...create, ...update];

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

@@ -0,0 +1,25 @@
+import { Assets, Asset, CalculatedChanges } from '../../../types';
+import DefaultHandler from './default';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            key: {
+                type: string;
+                pattern: string;
+            };
+            value: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+    additionalProperties: boolean;
+};
+export default class RulesConfigsHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(item: any): string;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+}

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

@@ -0,0 +1,11 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+};
+export default class TenantHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,35 @@
+import DefaultHandler from './default';
+import { Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            trigger_id: {
+                type: string;
+                properties: {
+                    action_name: {
+                        type: string;
+                        enum: string[];
+                    };
+                    display_name: {
+                        type: string;
+                        default: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default class TriggersHandler extends DefaultHandler {
+    existing: {
+        [key: string]: {
+            action_name: string;
+            display_name: string;
+        };
+    };
+    constructor(options: DefaultHandler);
+    getType(): Promise<DefaultHandler['existing']>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -45,7 +45,7 @@ exports.schema = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
 const constants_1 = __importDefault(require("../../constants"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'object',
     items: {

package/lib/tools/auth0/index.d.ts

@@ -0,0 +1,15 @@
+import { Assets, Auth0APIClient, BaseAuth0APIClient } from '../../types';
+import APIHandler from './handlers/default';
+import { ConfigFunction } from '../../configFactory';
+export declare type Stage = 'load' | 'validate' | 'processChanges';
+export default class Auth0 {
+    client: Auth0APIClient;
+    config: ConfigFunction;
+    assets: Assets;
+    handlers: APIHandler[];
+    constructor(client: BaseAuth0APIClient, assets: Assets, config: ConfigFunction);
+    runStage(stage: Stage): Promise<void>;
+    validate(): Promise<void>;
+    loadAll(): Promise<void>;
+    processChanges(): Promise<void>;
+}

package/lib/tools/auth0/schema.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    type: string;
+    $schema: string;
+    properties: {
+        exclude: {
+            type: string;
+            properties: {
+                [x: string]: Object;
+            };
+            default: {};
+        };
+    };
+    additionalProperties: boolean;
+};
+export default _default;

package/lib/tools/calculateChanges.d.ts

@@ -0,0 +1,26 @@
+import APIHandler from '../tools/auth0/handlers/default';
+import { Asset, CalculatedChanges } from '../types';
+/**
+ * @template T
+ * @param {typeof import('./auth0/handlers/default').default} handler
+ * @param {T} desiredAssetState
+ * @param {T} currentAssetState
+ * @param {string[]} [objectFields=[]]
+ * @param {boolean} [allowDelete]
+ * @returns T
+ */
+export declare function processChangedObjectFields({ handler, desiredAssetState, currentAssetState, allowDelete, }: {
+    handler: APIHandler;
+    desiredAssetState: Asset;
+    currentAssetState: Asset;
+    allowDelete: boolean;
+}): {
+    [x: string]: any;
+};
+export declare function calculateChanges({ handler, assets, existing, identifiers, allowDelete, }: {
+    handler: APIHandler;
+    assets: Asset[];
+    existing: Asset[];
+    identifiers: string[];
+    allowDelete: boolean;
+}): CalculatedChanges;

package/lib/tools/calculateChanges.js

@@ -4,17 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateChanges = exports.processChangedObjectFields = void 0;
-const logger_1 = __importDefault(require("./logger"));
+const logger_1 = __importDefault(require("../logger"));
 /**
  * @template T
  * @param {typeof import('./auth0/handlers/default').default} handler
  * @param {T} desiredAssetState
  * @param {T} currentAssetState
  * @param {string[]} [objectFields=[]]
- * @param {boolean} [allowDelete=false]
+ * @param {boolean} [allowDelete]
  * @returns T
  */
-function processChangedObjectFields({ handler, desiredAssetState, currentAssetState, allowDelete = false, }) {
+function processChangedObjectFields({ handler, desiredAssetState, currentAssetState, allowDelete, }) {
     const desiredAssetStateWithChanges = Object.assign({}, desiredAssetState);
     // eslint-disable-next-line no-restricted-syntax
     for (const fieldName of handler.objectFields) {