auth0-deploy-cli 7.6.0 → 7.8.0

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

@@ -20,21 +20,21 @@ exports.schema = {
     properties: {
         provider: {
             type: 'string',
-            enum: constants_1.default.GUARDIAN_PHONE_PROVIDERS
-        }
+            enum: constants_1.default.GUARDIAN_PHONE_PROVIDERS,
+        },
     },
-    additionalProperties: false
+    additionalProperties: false,
 };
 const isFeatureUnavailableError = (err) => {
     if (err.statusCode === 404) {
         // Older Management API version where the endpoint is not available.
         return true;
     }
-    if (err.statusCode === 403
-        && err.originalError
-        && err.originalError.response
-        && err.originalError.response.body
-        && err.originalError.response.body.errorCode === 'hooks_not_allowed') {
+    if (err.statusCode === 403 &&
+        err.originalError &&
+        err.originalError.response &&
+        err.originalError.response.body &&
+        err.originalError.response.body.errorCode === 'hooks_not_allowed') {
         // Recent Management API version, but with feature explicitly disabled.
         return true;
     }
@@ -47,7 +47,8 @@ class GuardianPhoneSelectedProviderHandler extends default_1.default {
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
             // in case client version does not support the operation
-            if (!this.client.guardian || typeof this.client.guardian.getPhoneFactorSelectedProvider !== 'function') {
+            if (!this.client.guardian ||
+                typeof this.client.guardian.getPhoneFactorSelectedProvider !== 'function') {
                 return {};
             }
             if (this.existing)

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

@@ -0,0 +1,23 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    properties: {
+        policies: {
+            type: string;
+            items: {
+                type: string;
+                enum: string[];
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export default class GuardianPoliciesHandler extends DefaultHandler {
+    existing: {
+        policies: Asset[];
+    };
+    constructor(options: any);
+    getType(): Promise<GuardianPoliciesHandler['existing'] | {}>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -22,16 +22,17 @@ exports.schema = {
             type: 'array',
             items: {
                 type: 'string',
-                enum: constants_1.default.GUARDIAN_POLICIES
-            }
-        }
+                enum: constants_1.default.GUARDIAN_POLICIES,
+            },
+        },
     },
-    additionalProperties: false
+    additionalProperties: false,
 };
 class GuardianPoliciesHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'guardianPolicies' }));
     }
+    //TODO: standardize empty object literal with more intentional empty indicator
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
             // in case client version does not support the operation

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

@@ -0,0 +1,58 @@
+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;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            triggerId: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            secrets: {
+                type: string;
+                description: string;
+                default: {};
+            };
+            dependencies: {
+                type: string;
+                default: {};
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class HooksHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    objString(hook: any): string;
+    processSecrets(hooks: any): Promise<void>;
+    getType(reload: boolean): Promise<Asset[]>;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+    validate(assets: any): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -15,10 +15,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = exports.excludeSchema = void 0;
 const default_1 = __importDefault(require("./default"));
 const constants_1 = __importDefault(require("../../constants"));
-const ALLOWED_TRIGGER_IDS = ['credentials-exchange', 'pre-user-registration', 'post-user-registration', 'post-change-password', 'send-phone-message'];
+const ALLOWED_TRIGGER_IDS = [
+    'credentials-exchange',
+    'pre-user-registration',
+    'post-user-registration',
+    'post-change-password',
+    'send-phone-message',
+];
 exports.excludeSchema = {
     type: 'array',
-    items: { type: 'string' }
+    items: { type: 'string' },
 };
 exports.schema = {
     type: 'array',
@@ -28,37 +34,37 @@ exports.schema = {
         properties: {
             script: {
                 type: 'string',
-                description: 'A script that contains the hook\'s code',
-                default: ''
+                description: "A script that contains the hook's code",
+                default: '',
             },
             name: {
                 type: 'string',
-                description: 'The name of the hook. Can only contain alphanumeric characters, spaces and \'-\'. Can neither start nor end with \'-\' or spaces',
-                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$'
+                description: "The name of the hook. Can only contain alphanumeric characters, spaces and '-'. Can neither start nor end with '-' or spaces",
+                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$',
             },
             enabled: {
                 type: 'boolean',
                 description: 'true if the hook is active, false otherwise',
-                default: false
+                default: false,
             },
             triggerId: {
                 type: 'string',
-                description: 'The hooks\'s trigger ID',
-                enum: ALLOWED_TRIGGER_IDS
+                description: "The hooks's trigger ID",
+                enum: ALLOWED_TRIGGER_IDS,
             },
             secrets: {
                 type: 'object',
                 description: 'List of key-value pairs containing secrets available to the hook.',
-                default: {}
+                default: {},
             },
             dependencies: {
                 type: 'object',
                 default: {},
-                description: 'List of key-value pairs of NPM dependencies available to the hook.'
-            }
+                description: 'List of key-value pairs of NPM dependencies available to the hook.',
+            },
         },
-        required: ['script', 'name', 'triggerId']
-    }
+        required: ['script', 'name', 'triggerId'],
+    },
 };
 const getCertainHook = (hooks, name, triggerId) => {
     let result = null;
@@ -89,11 +95,13 @@ class HooksHandler extends default_1.default {
             const changes = {
                 create: [],
                 update: [],
-                del: []
+                del: [],
+                conflicts: [],
             };
             hooks.forEach((hook) => {
                 const current = getCertainHook(allHooks, hook.name, hook.triggerId);
-                if (current) { // if the hook was deleted we don't care about its secrets
+                if (current) {
+                    // if the hook was deleted we don't care about its secrets
                     const oldSecrets = current.secrets || {};
                     const newSecrets = hook.secrets || {};
                     const create = {};
@@ -131,6 +139,7 @@ class HooksHandler extends default_1.default {
             })));
         });
     }
+    //@ts-ignore because hooks use a special reload argument
     getType(reload) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.existing && !reload) {
@@ -143,8 +152,10 @@ class HooksHandler extends default_1.default {
             try {
                 const hooks = yield this.client.hooks.getAll({ paginate: true, include_totals: true });
                 // hooks.getAll does not return code and secrets, we have to fetch hooks one-by-one
-                this.existing = yield Promise.all(hooks.map((hook) => this.client.hooks.get({ id: hook.id })
-                    .then((hookWithCode) => this.client.hooks.getSecrets({ id: hook.id })
+                this.existing = yield Promise.all(hooks.map((hook) => this.client.hooks
+                    .get({ id: hook.id })
+                    .then((hookWithCode) => this.client.hooks
+                    .getSecrets({ id: hook.id })
                     .then((secrets) => (Object.assign(Object.assign({}, hookWithCode), { secrets }))))));
                 return this.existing;
             }
@@ -168,7 +179,7 @@ class HooksHandler extends default_1.default {
                 del,
                 update: stripSecrets(update),
                 create: stripSecrets(create),
-                conflicts: stripSecrets(conflicts)
+                conflicts: stripSecrets(conflicts),
             };
         });
     }
@@ -183,9 +194,11 @@ class HooksHandler extends default_1.default {
                 return;
             const activeHooks = getActive(hooks);
             ALLOWED_TRIGGER_IDS.forEach((type) => {
-                if (activeHooks[type].length > 1) { // There can be only one!
+                if (activeHooks[type].length > 1) {
+                    // There can be only one!
                     const conflict = activeHooks[type].map((h) => h.name).join(', ');
                     const err = new Error(`Only one active hook allowed for "${type}" extensibility point. Conflicting hooks: ${conflict}`);
+                    //@ts-ignore need to investigate if appending status actually works here
                     err.status = 409;
                     throw err;
                 }
@@ -208,7 +221,7 @@ class HooksHandler extends default_1.default {
                 del: changes.del,
                 create: changes.create,
                 update: changes.update,
-                conflicts: changes.conflicts
+                conflicts: changes.conflicts,
             });
             yield this.processSecrets(hooks);
         });

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

@@ -0,0 +1,129 @@
+import APIHandler from './default';
+declare const _default: {
+    rules: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    rulesConfigs: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    hooks: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    pages: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    databases: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    clientGrants: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    resourceServers: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    clients: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    connections: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    tenant: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    emailProvider: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    emailTemplates: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactors: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactorProviders: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianFactorTemplates: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    migrations: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPhoneFactorMessageTypes: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPhoneFactorSelectedProvider: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    guardianPolicies: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    roles: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    actions: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    organizations: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    triggers: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    attackProtection: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    branding: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+};
+export default _default;

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

@@ -23,56 +23,60 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.attackProtection = exports.organizations = exports.triggers = exports.actions = exports.migrations = exports.prompts = exports.branding = exports.roles = exports.guardianPhoneFactorMessageTypes = exports.guardianPhoneFactorSelectedProvider = exports.guardianPolicies = exports.guardianFactorTemplates = exports.guardianFactorProviders = exports.guardianFactors = exports.clientGrants = exports.emailTemplates = exports.emailProvider = exports.tenant = exports.connections = exports.databases = exports.clients = exports.resourceServers = exports.pages = exports.hooks = exports.rulesConfigs = exports.rules = void 0;
+//TODO:
 const rules = __importStar(require("./rules"));
-exports.rules = rules;
 const rulesConfigs = __importStar(require("./rulesConfigs"));
-exports.rulesConfigs = rulesConfigs;
 const hooks = __importStar(require("./hooks"));
-exports.hooks = hooks;
 const pages = __importStar(require("./pages"));
-exports.pages = pages;
 const resourceServers = __importStar(require("./resourceServers"));
-exports.resourceServers = resourceServers;
 const databases = __importStar(require("./databases"));
-exports.databases = databases;
 const connections = __importStar(require("./connections"));
-exports.connections = connections;
 const clients = __importStar(require("./clients"));
-exports.clients = clients;
 const tenant = __importStar(require("./tenant"));
-exports.tenant = tenant;
 const emailProvider = __importStar(require("./emailProvider"));
-exports.emailProvider = emailProvider;
 const emailTemplates = __importStar(require("./emailTemplates"));
-exports.emailTemplates = emailTemplates;
 const clientGrants = __importStar(require("./clientGrants"));
-exports.clientGrants = clientGrants;
 const guardianFactors = __importStar(require("./guardianFactors"));
-exports.guardianFactors = guardianFactors;
 const guardianFactorProviders = __importStar(require("./guardianFactorProviders"));
-exports.guardianFactorProviders = guardianFactorProviders;
 const guardianFactorTemplates = __importStar(require("./guardianFactorTemplates"));
-exports.guardianFactorTemplates = guardianFactorTemplates;
 const guardianPolicies = __importStar(require("./guardianPolicies"));
-exports.guardianPolicies = guardianPolicies;
 const guardianPhoneFactorSelectedProvider = __importStar(require("./guardianPhoneFactorSelectedProvider"));
-exports.guardianPhoneFactorSelectedProvider = guardianPhoneFactorSelectedProvider;
 const guardianPhoneFactorMessageTypes = __importStar(require("./guardianPhoneFactorMessageTypes"));
-exports.guardianPhoneFactorMessageTypes = guardianPhoneFactorMessageTypes;
 const roles = __importStar(require("./roles"));
-exports.roles = roles;
 const branding = __importStar(require("./branding"));
-exports.branding = branding;
 const prompts = __importStar(require("./prompts"));
-exports.prompts = prompts;
 const migrations = __importStar(require("./migrations"));
-exports.migrations = migrations;
 const actions = __importStar(require("./actions"));
-exports.actions = actions;
 const triggers = __importStar(require("./triggers"));
-exports.triggers = triggers;
 const organizations = __importStar(require("./organizations"));
-exports.organizations = organizations;
 const attackProtection = __importStar(require("./attackProtection"));
-exports.attackProtection = attackProtection;
+const auth0ApiHandlers = {
+    rules,
+    rulesConfigs,
+    hooks,
+    pages,
+    resourceServers,
+    clients,
+    databases,
+    connections,
+    tenant,
+    emailProvider,
+    emailTemplates,
+    clientGrants,
+    guardianFactors,
+    guardianFactorProviders,
+    guardianFactorTemplates,
+    guardianPolicies,
+    guardianPhoneFactorSelectedProvider,
+    guardianPhoneFactorMessageTypes,
+    roles,
+    branding,
+    //@ts-ignore because prompts have not been universally implemented yet
+    prompts,
+    migrations,
+    actions,
+    triggers,
+    organizations,
+    attackProtection,
+};
+exports.default = auth0ApiHandlers; // TODO: apply stronger types to schema properties

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,15 +43,16 @@ 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' }
+    additionalProperties: { type: 'boolean' },
 };
 class MigrationsHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'migrations' }));
     }
+    //TODO: standardize empty object literal with more intentional empty indicator
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
             try {

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>;
+}