@ampsec/platform-client 62.23.0 → 63.0.0

package/src/dto/platform/index.ts

@@ -17,5 +17,6 @@ export * from './platform.saasComponents.dto';
 export * from './platform.saasUsers.dto';
 export * from './platform.ampSetting.dto';
 export * from './platform.tenants.dto';
+export * from './platform.tokens.dto';
 export * from './platform.users.dto';
 export * from './tenant.based.dto';

package/src/dto/platform/platform.tokens.dto.ts

@@ -0,0 +1,9 @@
+import {z} from 'zod';
+import {_TenantBased, _UpsertTenantBased} from './tenant.based.dto';
+import {_TokenDto, _TokenUpsertDto} from '../tokens.dto';
+
+export const _PlatformTokenDto = _TokenDto.merge(_TenantBased);
+export type PlatformTokenDto = z.infer<typeof _PlatformTokenDto>;
+
+export const _PlatformTokenUpsertDto = _TokenUpsertDto.merge(_UpsertTenantBased);
+export type PlatformTokenUpsertDto = z.infer<typeof _PlatformTokenUpsertDto>;

package/src/dto/saasComponents.dto.ts

@@ -89,7 +89,7 @@ export type SaasComponentUpsertDto = ChangeAwareUpsertDto & {
   /** Connector Id */
   cid: string;
   /**  */
-  kind: SaasComponentKind;
+  kind: SaasComponentKind | string;
   /** Context specific information related to the Saas Component */
   meta: SaasComponentMeta;
   /** User Id of the affected user */

package/src/dto/tokens.dto.ts

@@ -0,0 +1,11 @@
+import {z} from 'zod';
+import {UPSERT_DTO_MASK, _BaseDto} from './base.dto';
+
+export const _TokenDto = _BaseDto.extend({
+  displayValue: z.string().optional(),
+  key: z.string(),
+});
+export type TokenDto = z.infer<typeof _TokenDto>;
+
+export const _TokenUpsertDto = _TokenDto.partial(UPSERT_DTO_MASK);
+export type TokenUpsertDto = z.infer<typeof _TokenUpsertDto>;

package/src/services/AmpApi.ts

@@ -17,6 +17,7 @@ import {
   SaasUserDto,
   TenantDto,
   TenantUpsertDto,
+  TokenDto,
   UserDto,
 } from '../dto';
 import {
@@ -77,6 +78,7 @@ export class AmpApi {
   readonly saasUsers: AmpDataService<SaasUserDto>;
   readonly settings: AmpSettingsService;
   readonly tenants: AmpEntityService<TenantUpsertDto, TenantDto>;
+  readonly tokens: AmpDataService<TokenDto>;
   readonly users: AmpDataService<UserDto>;
   readonly usersInsights: UsersInsightsService;
   readonly prediction: PredictionService;
@@ -105,6 +107,7 @@ export class AmpApi {
     this.saasUsers = new AmpDataServiceImpl<SaasUserDto>(rest, KIND.SAAS_USERS);
     this.settings = new AmpSettingsService(rest);
     this.tenants = new AmpEntityServiceImpl<TenantUpsertDto, TenantDto>(rest, KIND.TENANTS);
+    this.tokens = new AmpDataServiceImpl<TokenDto>(rest, KIND.TOKENS);
     this.users = new AmpDataServiceImpl<UserDto>(rest, KIND.USERS);
     this.usersInsights = new UsersInsightsService(rest);
     this.prediction = new PredictionService(rest, KIND.FINDINGS);

package/src/services/AmpSdk.ts

@@ -36,6 +36,8 @@ import {
   PlatformStagedSaasComponentUpsertDto,
   PlatformStagedSaasUserDto,
   PlatformStagedSaasUserUpsertDto,
+  PlatformTokenDto,
+  PlatformTokenUpsertDto,
   ProviderDto,
   TenantDto,
   TenantUpsertDto,
@@ -96,6 +98,7 @@ export class AmpSdkServices {
   readonly stagedSaaSUsers: TruncatableAmpEntityService<PlatformStagedSaasUserUpsertDto, PlatformStagedSaasUserDto>;
   readonly settings: AmpSdkSettingsService;
   readonly tenants: AmpSdkTenantService<TenantUpsertDto, TenantDto>;
+  readonly tokens: AmpSdkTenantService<PlatformTokenUpsertDto, PlatformTokenDto>;
   readonly users: AmpSdkUserService;
 
   constructor(rest: RestClient) {
@@ -131,6 +134,7 @@ export class AmpSdkServices {
 
     this.settings = new AmpSdkSettingsService(rest);
     this.tenants = new AmpEntityServiceImpl<TenantUpsertDto, TenantDto>(rest, KIND.TENANTS, TARGET_API_PLATFORM);
+    this.tokens = new AmpEntityServiceImpl<PlatformTokenUpsertDto, PlatformTokenDto>(rest, KIND.TOKENS, TARGET_API_PLATFORM);
     this.users = new AmpSdkUserService(rest, TARGET_API_PLATFORM);
   }
 

package/src/services/ContentTemplateService.ts

@@ -0,0 +1,18 @@
+import _ from 'lodash';
+const JSON_PATH_PATTERN = /(\$\.(?:(?:[a-zA-Z0-9_]+)(?:\.[a-zA-Z0-9_]+)*)?)/g;
+
+export const fillJsonPathTemplate = (raw: string, meta: unknown) => {
+  const jsonPathMatches = raw.match(JSON_PATH_PATTERN);
+  let result = raw;
+  if (jsonPathMatches) {
+    jsonPathMatches.forEach(jsonPath => {
+      const path = jsonPath.replace('$.', '');
+      let value = _.get(meta, path, '?');
+      if (!_.isString(value)) {
+        value = JSON.stringify(value);
+      }
+      result = result.replace(jsonPath, value);
+    });
+  }
+  return result;
+};

package/src/services/constants.ts

@@ -37,6 +37,7 @@ export const KIND = {
   STAGED_SAAS_COMPONENTS: 'staged_saas_components',
   STAGED_SAAS_USERS: 'staged_saas_users',
   TENANTS: 'tenants',
+  TOKENS: 'tokens',
   USERS: 'users',
   USERS_INSIGHTS: 'coverage',
   WORKFLOW_PROGRESS: 'workflow_progress',

package/src/services/contentful.service.ts

@@ -1,6 +1,11 @@
+import {z} from 'zod';
 import type {Entry, EntrySkeletonType, EntryFieldTypes, EntryCollection, ContentfulClientApi} from 'contentful/dist/types';
 import * as contentful from 'contentful';
+import _ from 'lodash';
 
+/**
+ * @deprecated Use ContentService and MessageTemplateContent instead
+ */
 export type MessageTemplate = EntrySkeletonType & {
   contentTypeId: 'messageTemplate';
   fields: {
@@ -12,6 +17,8 @@ export type MessageTemplate = EntrySkeletonType & {
 };
 
 /**
+ * @deprecated Use ContentService instead
+ *
  * ContentfulService
  *
  * This client is a wrapper around the Contentful REST API meant to be used by
@@ -47,12 +54,14 @@ export class ContentfulService {
     return messageTemplates;
   };
 
-  getContentfulEntries = async <T extends EntrySkeletonType>(contentType: string, include?: number): Promise<EntryCollection<T>> => {
+  getContentfulEntries = async <T extends EntrySkeletonType>(contentType: string, include?: number, skip?: number, limit?: number): Promise<EntryCollection<T>> => {
     if (!this.contentfulClient) {
       throw new Error('Contenful client not initialized because of missing configurations: CONTENTFUL_SPACE_ID and CONTENTFUL_ACCESS_TOKEN must be set in the environment');
     }
     const entries = await this.contentfulClient.getEntries<T>({
       content_type: contentType,
+      skip,
+      limit,
       ...(include ? {include} : {}),
     });
     return entries;
@@ -66,3 +75,231 @@ export class ContentfulService {
     return entry;
   };
 }
+
+export enum ContentType {
+  MESSAGE_TEMPLATE = 'messageTemplate',
+  BACKEND_CONTENT = 'backendContent',
+  SERVICE_PROFILE = 'serviceProfile',
+  INTEGRATION = 'integration',
+  INTEGRATION_DOMAIN = 'integrationDomain',
+  FINDING = 'finding',
+  SECURITY_HUB_I18N = 'securityHubI18n',
+}
+
+const ContentfulRichText: z.ZodType<EntryFieldTypes.RichText> = z.any();
+
+export type ContentOptions = {
+  include?: number;
+  serviceFilter?: string | string[];
+  useCaseFilter?: string | string[];
+};
+
+const _BackendContent = z.object({
+  key: z.string(),
+  value: z.string(),
+  serviceFilter: z.array(z.string()),
+  useCaseFilter: z.array(z.string()),
+});
+export type BackendContent = z.infer<typeof _BackendContent>;
+
+const _ServiceProfile = z.object({
+  serviceKey: z.string(),
+  displayValue: z.string(),
+  logo: z.string(),
+  aliases: z.array(z.string()),
+});
+export type ServiceProfile = z.infer<typeof _ServiceProfile>;
+
+const _IntegrationDomain = z.object({
+  name: z.string(),
+  domain: z.string(),
+});
+export type IntegrationDomain = z.infer<typeof _IntegrationDomain>;
+
+const _FindingContent = z.object({
+  kind: z.string(),
+  title: z.string(),
+  displayText: z.string().optional(),
+  timeToComplete: z.string().optional(),
+  instructions: ContentfulRichText,
+});
+export type FindingContent = z.infer<typeof _FindingContent>;
+
+const _Integration = z.object({
+  name: z.string(),
+  providerKey: z.string(),
+  logo: z.string(),
+  icon: z.string().optional(),
+  tileDescription: z.string(),
+  overview: z.string(),
+  installationInstructions: ContentfulRichText,
+  termsOfUseLink: z.string().optional(),
+  privacyStatementLink: z.string().optional(),
+  supportLink: z.string().optional(),
+  formTextKeys: z.unknown(),
+  tags: z.array(z.string().optional()).default([]),
+  overviewLong: z.string(),
+  installModalDynamicTabs: z.unknown(),
+  overviewRichText: ContentfulRichText,
+  findings: _FindingContent,
+  domains: z.array(_IntegrationDomain),
+});
+export type Integration = z.infer<typeof _Integration>;
+
+const _I18nContent = z.object({
+  key: z.string(),
+  value: z.string(),
+  useCaseFilter: z.array(z.string()),
+});
+export type I18nContent = z.infer<typeof _I18nContent>;
+
+const _MessageTemplateContent = z.object({
+  id: z.string(),
+  body: z.string(),
+  subject: z.string().optional(),
+});
+export type MessageTemplateContent = z.infer<typeof _MessageTemplateContent>;
+
+export class ContentService {
+  private constructor(private readonly contentfulService: ContentfulService) {}
+
+  getEntries = async (contentType: ContentType, options: ContentOptions): Promise<unknown[]> => {
+    const entries = [] as unknown[];
+    let hasMore = true;
+    let skip = 0;
+    while (hasMore) {
+      const rawEntries = await this.contentfulService.getContentfulEntries(contentType, options.include, skip, 100);
+      entries.push(...rawEntries.items.map(entry => entry.fields));
+      skip += 100;
+      hasMore = rawEntries.skip + rawEntries.limit < rawEntries.total;
+    }
+    return entries;
+  };
+
+  getBackendContent = async (options?: ContentOptions): Promise<BackendContent[]> => {
+    const rawEntries = await this.getEntries(ContentType.BACKEND_CONTENT, options || {});
+    const entries = rawEntries.map(entry => _BackendContent.parse(entry));
+    return entries;
+  };
+
+  getMessageTemplates = async (): Promise<MessageTemplateContent[]> => {
+    const rawEntries = await this.contentfulService.getMessageTemplates();
+    const entries = rawEntries.items.map(entry => _MessageTemplateContent.parse(entry.fields));
+    return entries;
+  };
+
+  getIntegrationDomains = async (options?: ContentOptions): Promise<IntegrationDomain[]> => {
+    const rawEntries = await this.getEntries(ContentType.INTEGRATION_DOMAIN, options || {});
+    const entries = rawEntries.map(this.mapIntegrationDomain);
+    return entries;
+  };
+  private mapIntegrationDomain = (entry: unknown): IntegrationDomain => _IntegrationDomain.parse(entry);
+
+  getFindings = async (options?: ContentOptions): Promise<FindingContent[]> => {
+    const rawEntries = await this.getEntries(ContentType.FINDING, options || {});
+    const entries = rawEntries.map(this.mapFindings);
+    return entries;
+  };
+  private mapFindings = (entry: unknown): FindingContent => _FindingContent.parse(entry);
+
+  getIntegrations = async (options?: ContentOptions): Promise<Integration[]> => {
+    const rawEntries = await this.getEntries(ContentType.INTEGRATION, options || {});
+    const entries = rawEntries.map(entry => {
+      const logoUrl = _.get(entry, 'logo.fields.file.url');
+      _.set(entry as object, 'logo', logoUrl ? 'https:' + logoUrl : '');
+      const iconUrl = _.get(entry, 'icon.fields.file.url');
+      _.set(entry as object, 'icon', iconUrl ? 'https:' + iconUrl : '');
+      _.set(
+        entry as object,
+        'domains',
+        _.get(entry, 'domains', []).map(e => this.mapIntegrationDomain(_.get(e, 'fields')))
+      );
+      _.set(
+        entry as object,
+        'findings',
+        _.get(entry, 'findings', []).map(e => this.mapFindings(_.get(e, 'fields')))
+      );
+      return _Integration.parse(entry);
+    });
+    return entries;
+  };
+
+  getServiceProfiles = async (options?: ContentOptions): Promise<ServiceProfile[]> => {
+    const rawEntries = await this.getEntries(ContentType.SERVICE_PROFILE, options || {});
+    const entries = rawEntries.map(entry => {
+      const logoUrl = _.get(entry, 'logo.fields.file.url');
+      _.set(entry as object, 'logo', logoUrl ? 'https:' + logoUrl : '');
+      return _ServiceProfile.parse(entry);
+    });
+    return entries;
+  };
+
+  getI18nContent = async (options?: ContentOptions): Promise<I18nContent[]> => {
+    const rawEntries = await this.getEntries(ContentType.SECURITY_HUB_I18N, options || {});
+    const entries = rawEntries.map(entry => _I18nContent.parse(entry));
+    return entries;
+  };
+
+  static instance(): ContentService {
+    return new ContentService(new ContentfulService());
+  }
+}
+
+export class I18nContentService {
+  private content = {} as Record<string, I18nContent>;
+  private isInitialized: Promise<I18nContentService>;
+  private constructor(private readonly contentService: ContentService) {
+    this.isInitialized = this.refresh().then(service => {
+      console.debug('i18nContentService initialized');
+      return service;
+    });
+  }
+
+  init = async (): Promise<I18nContentService> => this.isInitialized;
+
+  refresh = async (): Promise<I18nContentService> => {
+    const content = await this.contentService.getI18nContent();
+    this.content = _.keyBy(content, 'key');
+    return this;
+  };
+
+  /**
+   * Example Usage:
+   * ```ts
+   * const i18n = await i18nContentService.instance();
+   * await i18n.init();
+   * const value = i18n.g('LOADING', 'Loading...');
+   * ```
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  g = (key: string, defaultValue?: string): string => {
+    return _.get(this.content, [key, 'value'], defaultValue || key);
+  };
+
+  /**
+   * Example Usage:
+   * ```ts
+   * const i18n = await I18nContentService.instance();
+   * await i18n.init();
+   * const t = i18n.getLookupFunction();
+   * const value = t('LOADING', 'Loading...');
+   * // or more simply
+   * return <div>{t('Loading...')}</div>
+   * // Note this can be use to extend functionality of a Typography component, e.g.
+   * const MyTypography = (props: {children: string}) => <Typography>{t(props.children)}</Typography>
+   * return <MyTypography>Loading...</MyTypography>
+   * ```
+   * @returns
+   */
+  getLookupFunction = () => this.g;
+
+  private static _instance: I18nContentService | undefined;
+  static instance(_options?: {locale?: 'en'; useCaseFilter?: string | string[]}) {
+    if (!I18nContentService._instance) {
+      I18nContentService._instance = new I18nContentService(ContentService.instance());
+    }
+    return I18nContentService._instance;
+  }
+}

package/src/services/index.ts

@@ -2,6 +2,7 @@ export * from './AmpApi';
 export * from './EngageApi';
 export * from './AmpSdk';
 export * from './constants';
+export * from './ContentTemplateService';
 export * from './data.service';
 export * from './entity.service';
 export * from './findingsInsights.service';

package/src/services/rest/RestClient.ts

@@ -16,7 +16,7 @@ export type AmpRestClientOptions = {
   rateLimitStrategy?: RestClientRateLimitStrategy;
   logger?: AmpLogger;
   client?: AxiosStatic;
-  /** Throws errors on non-200 responses if `true`. Default `false` */
+  /** Throws errors on non-200 responses if `true`*/
   strict?: boolean;
 };
 
@@ -123,7 +123,7 @@ export const getAmpRestClient = (options: AmpRestClientOptions): RestClient => {
     rateLimitStrategy: new StaticRestClientRateLimitStrategy(50),
     logger: options.logger,
     client: options.client,
-    strict: options.strict,
+    strict: _.isUndefined(options.strict) ? true : options.strict,
   });
   return ampClient;
 };