Extensibility as custom phone provider deploy cli support

src/context/defaults.ts

@@ -52,3 +52,21 @@ export function emailProviderDefaults(emailProvider) {
 
   return updated;
 }
+
+export function phoneProviderDefaults(phoneProvider) {
+  // eslint-disable-line
+  const updated = { ...phoneProvider };
+
+  const apiKeyProviders = ['twilio'];
+
+  // Add placeholder for credentials as they cannot be exported
+  const { name } = updated;
+
+  if (apiKeyProviders.includes(name)) {
+    updated.credentials = {
+      auth_token: `##${name.toUpperCase()}_AUTH_TOKEN##`,
+      ...(updated.credentials || {}),
+    };
+  }
+  return updated;
+}

src/context/directory/handlers/index.ts

@@ -19,6 +19,7 @@ import organizations from './organizations';
 import triggers from './triggers';
 import attackProtection from './attackProtection';
 import branding from './branding';
+import phoneProviders from './phoneProvider';
 import logStreams from './logStreams';
 import prompts from './prompts';
 import customDomains from './customDomains';
@@ -66,6 +67,7 @@ const directoryHandlers: {
   triggers,
   attackProtection,
   branding,
+  phoneProviders,
   logStreams,
   prompts,
   customDomains,

src/context/directory/handlers/phoneProvider.ts

@@ -0,0 +1,50 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { constants } from '../../../tools';
+
+import { existsMustBeDir, isFile, dumpJSON, loadJSON } from '../../../utils';
+import { DirectoryHandler } from '.';
+import DirectoryContext from '..';
+import { ParsedAsset } from '../../../types';
+import { PhoneProvider } from '../../../tools/auth0/handlers/phoneProvider';
+
+type ParsedPhoneProvider = ParsedAsset<'phoneProviders', PhoneProvider[]>;
+
+function parse(context: DirectoryContext): ParsedPhoneProvider {
+  const phoneProvidersFolder = path.join(context.filePath, constants.PHONE_PROVIDER_DIRECTORY);
+  if (!existsMustBeDir(phoneProvidersFolder)) return { phoneProviders: null }; // Skip
+
+  const providerFile = path.join(phoneProvidersFolder, 'provider.json');
+
+  if (isFile(providerFile)) {
+    return {
+      phoneProviders: loadJSON(providerFile, {
+        mappings: context.mappings,
+        disableKeywordReplacement: context.disableKeywordReplacement,
+      }),
+    };
+  }
+
+  return { phoneProviders: null };
+}
+
+async function dump(context: DirectoryContext): Promise<void> {
+  const { phoneProviders } = context.assets;
+  if (!phoneProviders) {
+    return;
+  }// Skip, nothing to dump
+
+  const phoneProvidersFolder = path.join(context.filePath, constants.PHONE_PROVIDER_DIRECTORY);
+  fs.ensureDirSync(phoneProvidersFolder);
+
+  const phoneProviderFile = path.join(phoneProvidersFolder, 'provider.json');
+  // @ts-ignore
+  dumpJSON(phoneProviderFile,  phoneProviders.map(({ created_at, updated_at, tenant, channel, credentials, ...rest }) => rest));
+}
+
+const phoneProvidersHandler: DirectoryHandler<ParsedPhoneProvider> = {
+  parse,
+  dump,
+};
+
+export default phoneProvidersHandler;

src/context/yaml/handlers/index.ts

@@ -19,6 +19,7 @@ import actions from './actions';
 import triggers from './triggers';
 import attackProtection from './attackProtection';
 import branding from './branding';
+import phoneProviders from './phoneProvider';
 import logStreams from './logStreams';
 import prompts from './prompts';
 import customDomains from './customDomains';
@@ -64,6 +65,7 @@ const yamlHandlers: { [key in AssetTypes]: YAMLHandler<{ [key: string]: unknown
   triggers,
   attackProtection,
   branding,
+  phoneProviders,
   logStreams,
   prompts,
   customDomains,

src/context/yaml/handlers/phoneProvider.ts

@@ -0,0 +1,36 @@
+import { YAMLHandler } from '.';
+import YAMLContext from '..';
+import { PhoneProvider } from '../../../tools/auth0/handlers/phoneProvider';
+import { ParsedAsset } from '../../../types';
+
+type ParsedPhoneProviders = ParsedAsset<'phoneProviders', PhoneProvider[] >;
+
+async function parse(context: YAMLContext): Promise<ParsedPhoneProviders> {
+  const { phoneProviders } = context.assets;
+
+  if (!phoneProviders) return { phoneProviders: null };
+
+  console.log(phoneProviders);
+
+  return {
+    phoneProviders,
+  };
+}
+
+async function dump(context: YAMLContext): Promise<ParsedPhoneProviders> {
+  if (!context.assets.phoneProviders) return { phoneProviders: null };
+
+  const { phoneProviders } = context.assets;
+
+  return {
+    // @ts-ignore
+    phoneProviders: phoneProviders.map(({ created_at, updated_at, tenant, channel, credentials, ...rest }) => rest)
+  };
+}
+
+const phoneProviderHandler: YAMLHandler<ParsedPhoneProviders> = {
+  parse,
+  dump,
+};
+
+export default phoneProviderHandler;

src/tools/auth0/handlers/emailProvider.ts

@@ -2,7 +2,6 @@ import { EmailProviderCreate } from 'auth0';
 import { isEmpty } from 'lodash';
 import DefaultHandler, { order } from './default';
 import { Asset, Assets } from '../../../types';
-import log from '../../../logger';
 
 export const schema = { type: 'object' };
 
@@ -46,7 +45,6 @@ export default class EmailProviderHandler extends DefaultHandler {
     if (Object.keys(emailProvider).length === 0) {
       if (this.config('AUTH0_ALLOW_DELETE') === true) {
         // await this.client.emails.delete(); is not supported
-        existing.enabled = false;
         if (isEmpty(existing.credentials)) {
           delete existing.credentials;
         }
@@ -57,14 +55,6 @@ export default class EmailProviderHandler extends DefaultHandler {
       return;
     }
 
-    if (existing.name) {
-      if (existing.name !== emailProvider.name) {
-        // Delete the current provider as it's different
-        // await this.client.emailProvider.delete(); is not supported
-        existing.enabled = false;
-      }
-    }
-
     if (existing.name) {
       const updated = await this.client.emails.update(emailProvider);
       this.updated += 1;

src/tools/auth0/handlers/index.ts

@@ -18,6 +18,7 @@ import * as guardianPhoneFactorSelectedProvider from './guardianPhoneFactorSelec
 import * as guardianPhoneFactorMessageTypes from './guardianPhoneFactorMessageTypes';
 import * as roles from './roles';
 import * as branding from './branding';
+import * as phoneProviders from './phoneProvider';
 import * as prompts from './prompts';
 import * as actions from './actions';
 import * as triggers from './triggers';
@@ -55,6 +56,7 @@ const auth0ApiHandlers: { [key in AssetTypes]: any } = {
   guardianPhoneFactorMessageTypes,
   roles,
   branding,
+  phoneProviders,
   //@ts-ignore because prompts have not been universally implemented yet
   prompts,
   actions,

src/tools/auth0/handlers/phoneProvider.ts

@@ -0,0 +1,201 @@
+import {
+  CreatePhoneProviderRequest,
+  DeletePhoneProviderRequest,
+  GetBrandingPhoneProviders200ResponseProvidersInner,
+  UpdatePhoneProviderOperationRequest
+} from 'auth0';
+import DefaultHandler, { order } from './default';
+import { Assets } from '../../../types';
+import log from '../../../logger';
+
+export type PhoneProvider = GetBrandingPhoneProviders200ResponseProvidersInner;
+export default class PhoneProviderHandler extends DefaultHandler {
+  existing: PhoneProvider[] | null;
+
+  constructor(options: DefaultHandler) {
+    super({
+      ...options,
+      type: 'phoneProviders',
+      id: 'id',
+    });
+  }
+
+  objString(provider: PhoneProvider) : string {
+    return super.objString({ name: provider.name, disabled: provider.disabled }); //Que
+  }
+
+  async getType(): Promise<PhoneProvider[] | null> {
+    if (!this.existing) {
+      this.existing = await this.getPhoneProviders();
+    }
+
+    return this.existing;
+  }
+
+  async getPhoneProviders(): Promise<PhoneProvider[] | null> {
+    const { data: response } = await this.client.branding.getAllPhoneProviders();
+    return response.providers ?? [];
+  }
+
+  @order('60')
+  async processChanges(assets: Assets): Promise<void> {
+    const { phoneProviders } = assets;
+
+    // Non-existing section means themes doesn't need to be processed
+    if (!phoneProviders) return;
+
+    // Empty array means themes should be deleted
+    if (phoneProviders.length === 0) {
+      return this.deletePhoneProviders();
+    }
+
+    return this.updatePhoneProviders(phoneProviders);
+  }
+
+  async deletePhoneProviders(): Promise<void> {
+    if (!this.config('AUTH0_ALLOW_DELETE')) {
+      return;
+    }
+
+    // if phone providers exists we need to delete it
+    const currentProviders = await this.getPhoneProviders();
+    if (currentProviders === null || currentProviders.length === 0) {
+      return;
+    }
+
+    const currentProvider = currentProviders[0];
+    await this.client.branding.deletePhoneProvider(<DeletePhoneProviderRequest>{ id: currentProvider.id });
+    // await this.client.branding.deletePhoneProvider({ 'id': currentProvider.id }); //Quee
+
+    this.deleted += 1;
+    this.didDelete(currentProvider);
+  }
+
+  async updatePhoneProviders(phoneProviders: PhoneProvider[]): Promise<void> {
+    if (phoneProviders.length > 1) {
+      log.warn('Currently only one phone provider is supported per tenant');
+    }
+
+    const currentProviders = await this.getPhoneProviders();
+
+    const providerReqPayload = ((): Omit<PhoneProvider, 'id'> => {
+      // Removing id from update and create payloads, otherwise API will error
+      // id may be required to handle if `--export_ids=true`
+      const payload = phoneProviders[0];
+      // @ts-ignore to quell non-optional id property, but we know that it's ok to delete
+      delete payload.id;
+      return payload;
+    })();
+
+    if (currentProviders === null || currentProviders.length === 0) {
+      // if provider does not exist, create it
+      await this.client.branding.configurePhoneProvider(providerReqPayload as CreatePhoneProviderRequest);
+    } else {
+      const currentProvider = currentProviders[0];
+      // if provider exists, overwrite it
+      this.created += 1;
+      await this.client.branding.updatePhoneProvider({ id: currentProvider.id } as UpdatePhoneProviderOperationRequest, providerReqPayload);
+    }
+
+    this.updated += 1;
+    this.didUpdate(phoneProviders[0]);
+  }
+}
+
+const TwilioCredentialsSchema = {
+  type: 'object',
+  required: ['auth_token'],
+  properties: {
+    auth_token: {
+      type: 'string',
+      minLength: 1,
+      maxLength: 255,
+    },
+  },
+  additionalProperties: false,
+};
+
+const TwilioConfigurationSchema = {
+  type: 'object',
+  required: ['sid', 'delivery_methods'],
+  additionalProperties: false,
+  properties: {
+    default_from: {
+      type: 'string',
+    },
+    mssid: {
+      type: 'string',
+    },
+    sid: {
+      type: 'string',
+    },
+    delivery_methods: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['text', 'voice'],
+      },
+      minItems: 1,
+      uniqueItems: true,
+    },
+  },
+};
+
+const CustomCredentialsSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {},
+};
+
+const CustomConfigurationSchema = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['delivery_methods'],
+  properties: {
+    delivery_methods: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['text', 'voice'],
+      },
+      minItems: 1,
+      uniqueItems: true,
+    },
+  },
+};
+
+export const schema = {
+  type: 'array',
+  description: 'List of phone provider configurations',
+  items: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'string',
+        minLength: 1,
+        maxLength: 255,
+      },
+      name: {
+        type: 'string',
+        description: 'Name of the phone notification provider',
+        enum: ['twilio', 'custom'],
+        minLength: 1,
+        maxLength: 100,
+      },
+      disabled: {
+        type: 'boolean',
+        description: 'Whether the provider is enabled (false) or disabled (true).',
+        defaultValue: false,
+      },
+      configuration: {
+        type: 'object',
+        anyOf: [TwilioConfigurationSchema, CustomConfigurationSchema],
+      },
+      credentials: {
+        description: 'Provider credentials required to authenticate to the provider.',
+        anyOf: [TwilioCredentialsSchema, CustomCredentialsSchema],
+      },
+    },
+    additionalProperties: false,
+  },
+};

src/tools/constants.ts

@@ -96,6 +96,7 @@ const constants = {
   CLIENTS_DIRECTORY: 'clients',
   CLIENTS_GRANTS_DIRECTORY: 'grants',
   BRANDING_DIRECTORY: 'branding',
+  PHONE_PROVIDER_DIRECTORY: 'phone-providers',
   BRANDING_TEMPLATES_DIRECTORY: 'templates',
   BRANDING_TEMPLATES_YAML_DIRECTORY: 'branding_templates',
   CLIENTS_CLIENT_NAME: 'clients',