@w3-commons/js-build-resources 0.0.1-security → 1.0.4

package/settings-service/src/types/ApiKey.ts

@@ -0,0 +1,19 @@
+export class ApiKey {
+  public readonly appId: string;
+
+  public readonly key: string;
+
+  public readonly createdBy: string;
+
+  public readonly createdDate: Date;
+
+  public readonly updatedDate: Date;
+
+  constructor(appId: string, key: string, createdBy: string, createdDate: Date, updatedDate: Date) {
+    this.appId = appId;
+    this.key = key;
+    this.createdBy = createdBy;
+    this.createdDate = createdDate;
+    this.updatedDate = updatedDate;
+  }
+}

package/settings-service/src/types/IRequest.ts

@@ -0,0 +1,9 @@
+import { Request } from 'restify';
+
+import { IRequestAuthorization } from './IRequestAuthorization';
+
+export interface IRequest extends Request {
+  authorization: IRequestAuthorization;
+  isAuthenticated: boolean;
+  auth_policy: string;
+}

package/settings-service/src/types/IRequestAuthorization.ts

@@ -0,0 +1,5 @@
+import { RequestAuthorization } from 'restify';
+
+export interface IRequestAuthorization extends RequestAuthorization {
+  token?: string;
+}

package/settings-service/src/types/IRouteOptions.ts

@@ -0,0 +1,5 @@
+import { RouteOptions } from 'restify';
+
+export interface IRouteOptions extends RouteOptions {
+  authRequired?: boolean;
+}

package/settings-service/src/types/QueryResultsTypes.ts

@@ -0,0 +1,6 @@
+import { UserSettingsDBRow } from './settingsRepoTypes';
+
+export interface QueryResults {
+  pageState?: string | null;
+  settings?: UserSettingsDBRow[];
+}

package/settings-service/src/types/UserSettingsControllerTypes.ts

@@ -0,0 +1,5 @@
+import { UserSettings } from './settingsRepoTypes';
+
+export interface UserSettingsResult {
+  [key: string]: UserSettings;
+}

package/settings-service/src/types/W3IdUser.ts

@@ -0,0 +1,36 @@
+export interface W3IdTenantId {
+  tenantId?: string;
+}
+
+interface W3IdUser {
+  at_hash?: string;
+  lastName?: string;
+  sub?: string;
+  realmName?: string;
+  uniqueSecurityName?: string;
+  iss?: string;
+  dn?: string;
+  preferred_username?: string;
+  token_type?: string;
+  client_id?: string;
+  uid?: string;
+  acr?: string;
+  emailAddress?: string;
+  blueGroups?: string[];
+  grant_type?: string;
+  restrictEntitlements?: boolean;
+  scope?: string;
+  exp?: number;
+  app_id?: string;
+  iat?: number;
+  ext?: W3IdTenantId;
+  active?: boolean;
+  cn?: string;
+  aud?: string | string[];
+  firstName?: string;
+  grant_id?: string;
+  userType?: string;
+  category?: string;
+}
+
+export default W3IdUser;

package/settings-service/src/types/settingsRepoTypes.ts

@@ -0,0 +1,61 @@
+export type UserSettings = {
+  [key: string]: string | null | Array<string | null>;
+};
+
+export interface UserSettingsDBRow {
+  user_id: string;
+  app_id: string;
+  setting_name: string;
+  setting_value: string;
+}
+
+export type DeprecatedValues = {
+  [key: string]: string;
+};
+export interface AppSettings {
+  default?: string | null;
+  options: string[];
+  setting_type: string | null;
+  deprecated_values: DeprecatedValues | null;
+}
+
+export interface AppSettingsConfigDBRow {
+  app_id: string;
+  setting_name: string;
+  setting_options: string[];
+  setting_type: string;
+  setting_default: string | null;
+  deprecated_values: string | null;
+}
+
+export type AppSettingsResponse = {
+  [key: string]: AppSettings;
+};
+
+export interface FetchAndMapLanguagesArgs {
+  userId: string;
+  appId: string;
+  result: UserSettings;
+  filter: AppSettingsResponse;
+  settingsDBRows: UserSettingsDBRow[];
+}
+export interface UpdateAppSettingsArgs {
+  appId: string;
+  settingName: string;
+  settingDefault?: string | null;
+  settingOptions: string[];
+  settingType?: string | null;
+  deprecatedValues?: string | null;
+}
+
+export interface BatchQuery {
+  query: string;
+  params: string[];
+}
+
+export interface GetAllSettingsOptions {
+  pageState?: string;
+  appId?: string;
+  settingName?: string;
+  fetchSize: number;
+}

package/settings-service/src/types/unifiedProfileTypes.ts

@@ -0,0 +1,10 @@
+export enum ResponseFormat {
+  MASTER = 'master',
+}
+export interface ProfileResponse {
+  content: {
+    c: string;
+    languages?: string[];
+    preferredLanguage?: string;
+  };
+}

package/settings-service/src/unified-profile/UnifiedProfileClient.ts

@@ -0,0 +1,29 @@
+import axios, { AxiosInstance } from 'axios';
+import { logger } from '../logger/logger';
+import { ProfileResponse, ResponseFormat } from '../types/unifiedProfileTypes';
+
+export default class UnifiedProfileClient {
+  public readonly client: AxiosInstance;
+
+  constructor() {
+    this.client = axios.create({
+      baseURL: 'https://unified-profile-api.us-south-k8s.intranet.ibm.com/v3',
+    });
+  }
+
+  public async getProfile(userId: string): Promise<ProfileResponse | undefined> {
+    try {
+      const response = await this.client.get(`/profiles/${userId}/profile`, {
+        params: {
+          format: ResponseFormat.MASTER,
+        },
+      });
+      return response.data;
+    } catch (error) {
+      logger.debug(
+        `${UnifiedProfileClient.name} | ${this.getProfile.name}() | Error fetching information from Unified Profile: ${error} `,
+      );
+      return undefined;
+    }
+  }
+}

package/settings-service/src/unified-profile/UnifiedProfileClientFactory.ts

@@ -0,0 +1,10 @@
+import UnifiedProfileClient from './UnifiedProfileClient';
+
+export class UnifiedProfileClientFactory {
+  private static singleton: UnifiedProfileClient;
+
+  static accessOrCreateSingleton(): UnifiedProfileClient {
+    this.singleton = this.singleton || new UnifiedProfileClient();
+    return this.singleton;
+  }
+}

package/settings-service/src/unified-profile/unifiedProfileUtils.ts

@@ -0,0 +1,22 @@
+import { logger } from '../logger/logger';
+import { UnifiedProfileClientFactory } from './UnifiedProfileClientFactory';
+import { ProfileResponse } from '../types/unifiedProfileTypes';
+
+const CLASS_NAME = 'unifiedProfileUtils';
+
+/**
+ * This method fetches user profile from Unified Profile
+ *
+ * @param userId
+ *
+ */
+export async function getUnifiedProfile(userId: string): Promise<ProfileResponse | undefined> {
+  const client = UnifiedProfileClientFactory.accessOrCreateSingleton();
+  const profile = await client.getProfile(userId);
+  if (profile) {
+    logger.debug(
+      `${CLASS_NAME} | ${getUnifiedProfile.name}() | pulled profile from Unified Profile service for user: ${userId}`,
+    );
+  }
+  return profile;
+}

package/settings-service/src/util/downloadCassandra.ts

@@ -0,0 +1,34 @@
+import axios from 'axios';
+import fs from 'fs';
+import http from 'axios/lib/adapters/http';
+import { settings } from '../config/config';
+import { CassandraClientFactory } from '../repo/CassandraClientFactory';
+import { logger } from '../logger/logger';
+
+axios.defaults.adapter = http;
+
+export async function downloadCassandra(): Promise<void> {
+  if (process.env.NODE_ENV === 'dev') return;
+  if (fs.existsSync(settings.cassandraCertsFilePath)) return;
+  await new Promise<void>((resolve, reject) => {
+    axios.get(settings.cassandraCertsURL, { responseType: 'stream' }).then(
+      (response) => {
+        const stream = response.data.pipe(fs.createWriteStream(settings.cassandraCertsFilePath));
+        stream.on('finish', async () => {
+          stream.close();
+          try {
+            const cassandraClient = CassandraClientFactory.accessOrCreateSingleton();
+            await cassandraClient.connect();
+          } catch (err) {
+            logger.error('Error connecting to Cassandra client', err);
+          }
+          resolve();
+        });
+      },
+      (err) => {
+        logger.error('Error fetching Datastax connection file', err);
+        reject(err);
+      },
+    );
+  });
+}

package/settings-service/src/util/isocodeMapper.ts

@@ -0,0 +1,22 @@
+import { logger } from '../logger/logger';
+
+export function reverseMapFullNameToIsoCode(
+  fullName: string,
+  map: { [isoCode: string]: { people: string | string[] } },
+): string | null {
+  for (const [k, v] of Object.entries(map)) {
+    if (typeof v.people === 'string') {
+      if (v.people === fullName) {
+        return k;
+      }
+    } else {
+      for (const language of v.people) {
+        if (language === fullName) {
+          return k;
+        }
+      }
+    }
+  }
+  logger.error(`isocode not found for key ${fullName}, returning null | ${reverseMapFullNameToIsoCode.name}`);
+  return null;
+}