@meltwater/conversations-api-services 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltwater/conversations-api-services",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Repository to contain all conversations api services shared across our services",
   "type": "module",
   "main": "src/data-access/index.js",

package/src/data-access/http/ir.client.js

@@ -1,7 +1,6 @@
 import { v4 } from 'uuid';
 import superagent from 'superagent';
 import logger from '../../lib/logger.js';
-import { awsSecrets } from './secrets.js';
 import configuration from '../../lib/configuration.js';
 import { metricN } from '../../lib/metrics.helper.js';
 
@@ -16,21 +15,19 @@ export class IRClient {
     }
 
     async init() {
-        let irApiKey = process.env.IR_API_KEY
-            ? { IR_API_KEY: process.env.IR_API_KEY }
-            : await awsSecrets.getSecret('IR_API_KEY');
+        let irApiKey = configuration.get('IR_API_KEY');
 
         this.searchServicesUrl = configuration.get('SEARCH_SERVICE_URL');
-        this.searchServicesKey = irApiKey.IR_API_KEY;
+        this.searchServicesKey = irApiKey;
 
         this.documentRevisionsServiceUrl = configuration.get(
             'DOCUMENT_REVISIONS_SERVICE_URL'
         );
         this.documentServiceUrl = configuration.get('DOCUMENT_SERVICE_URL');
-        this.documentServiceKey = irApiKey.IR_API_KEY;
+        this.documentServiceKey = irApiKey;
 
         this.exportApiUrl = configuration.get('EXPORT_API_URL');
-        this.exportApiKey = irApiKey.IR_API_KEY;
+        this.exportApiKey = irApiKey;
     }
 
     async addRevisionsToDocuments(operations) {

package/src/data-access/http/linkedInApi.client.js

@@ -93,6 +93,59 @@ export class LinkedInApiClient {
         return response.connection || response;
     }
 
+    async deleteMessage(document) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: {
+                    storage: { privateTo: companyId },
+                },
+            },
+            metaData: {
+                externalId,
+                inReplyTo: { id: inReplyToId},
+            },
+        } = document;
+
+        let response;
+        let query = `${configuration.get(
+                  'LINKEDIN_API'
+              )}/socialActions/${fixedEncodeURIComponent(inReplyToId)}/comments/${fixedEncodeURIComponent(externalId)}`;
+
+        try {
+            let credential = await this.tokenService.getByCredentialId(
+                credentialId,
+                companyId
+            );
+            
+            this.logger.debug(`${documentId} - trying Delete `, {
+                query,
+            });
+            response = await superagent
+                .delete(query)
+                .timeout(5000)
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202401',
+                });
+
+            this.logger.info(
+                `Native Linkedin API Delete Comment Response for documentId ${documentId}`,
+                { response }
+            );
+        } catch (err) {
+            this.logger.error(documentId + ' - exception details', {
+                err,
+            });
+            throw err;
+        }
+        return response;
+    }
+
     async publishComment(document, mediaId) {
         // command
         const {

package/src/data-access/index.js

@@ -1,7 +1,5 @@
 import { awsS3Client } from './http/amazonS3.js';
 import { assetManagerTvmRepository } from './http/asset-manager-tvm.client.js';
-import { assetManagerClient } from './http/asset-manager.client.js';
-import { awsSecrets } from './http/secrets.js';
 import { CompanyApiClient } from './http/companiesApi.client.js';
 import { CredentialsApiClient } from './http/credentialsApi.client.js';
 import { EntitlementsApiClient } from './http/entitlementsApi.client.js';
@@ -18,8 +16,6 @@ import { WarpZoneApiClient } from './http/WarpZoneApi.client.js';
 export {
     awsS3Client,
     assetManagerTvmRepository,
-    assetManagerClient,
-    awsSecrets,
     CompanyApiClient,
     CredentialsApiClient,
     EntitlementsApiClient,

package/src/data-access/http/asset-manager.client.js

@@ -1,164 +0,0 @@
-import superagent from 'superagent';
-import logger from '../../lib/logger.js';
-import { generateToken } from '../../lib/auth.helpers.js';
-
-class AssetManagerClient {
-    apiKey;
-    constructor() {
-        const { GRAPHQL_GATEWAY_URL } = process.env;
-        this.gatewayURL = GRAPHQL_GATEWAY_URL;
-        this.request = superagent;
-    }
-
-    /**
-     *
-     * @param {*} assetQuery
-     * @param {*} assetQuery.assetId
-     * @param {*} assetQuery.userId
-     * @param {*} assetQuery.companyId
-     * @returns
-     */
-    async getURL({ assetId, userId, companyId }) {
-        try {
-            const response = await this.request
-                .post(`${this.gatewayURL}`)
-                .set('apollographql-client-name', 'phoenix-conversations')
-                .set('Authorization', await generateToken(userId, companyId))
-                .send({
-                    query: `
-                        query getAssetUrlForPublishing(
-                            $filter: AssetFilterInput
-                        ) {
-                            assets(filter: $filter) {
-                                edges {
-                                    node {
-                                        url
-                                    }
-                                }
-                            }
-                        }
-                    `,
-                    operationName: 'getAssetUrlForPublishing',
-                    variables: {
-                        filter: {
-                            ids: [assetId],
-                            uploadPath: [
-                                'ASSET_MANAGER',
-                                'ENGAGE_CONVERSATIONS',
-                            ],
-                        },
-                    },
-                });
-            return response.body;
-        } catch (exception) {
-            // How would you prefer to handle this
-            logger.error('Error getting asset url', {
-                assetId,
-                userId,
-                companyId,
-                exception,
-            });
-            throw exception;
-        }
-    }
-
-    async getAssetUrlAndSize({ assetId, userId, companyId }) {
-        try {
-            const response = await this.request
-                .post(`${this.gatewayURL}`)
-                .set('apollographql-client-name', 'grimoire-publisher')
-                .set('Authorization', await generateToken(userId, companyId))
-                .send({
-                    query: `
-                        query getAssetUrlAndSizeForPublishing(
-                            $filter: AssetFilterInput
-                        ) {
-                            assets(filter: $filter) {
-                                edges {
-                                    node {
-                                        url
-                                        size {
-                                            bytes
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    `,
-                    operationName: 'getAssetUrlAndSizeForPublishing',
-                    variables: {
-                        filter: {
-                            ids: [assetId],
-                            uploadPath: [
-                                'ASSET_MANAGER',
-                                'ENGAGE_CONVERSATIONS',
-                            ],
-                        },
-                    },
-                });
-            return response.body;
-        } catch (exception) {
-            // How would you prefer to handle this
-            logger.error('Error getting asset', {
-                assetId,
-                userId,
-                companyId,
-                exception,
-            });
-            throw exception;
-        }
-    }
-
-    async getAsset({ assetId, userId, companyId }) {
-        try {
-            const response = await this.request
-                .post(`${this.gatewayURL}`)
-                .set('apollographql-client-name', 'grimoire-publisher')
-                .set('Authorization', await generateToken(userId, companyId))
-                .send({
-                    query: `
-                        query getAssetUrlAndSizeForPublishing(
-                            $filter: AssetFilterInput
-                        ) {
-                            assets(filter: $filter) {
-                                edges {
-                                    node {
-                                        fileName
-                                        url
-                                        size {
-                                            bytes
-                                        }
-                                        path
-                                        type
-                                        mimeType
-                                    }
-                                }
-                            }
-                        }
-                    `,
-                    operationName: 'getAssetUrlAndSizeForPublishing',
-                    variables: {
-                        filter: {
-                            ids: [assetId],
-                            uploadPath: [
-                                'ASSET_MANAGER',
-                                'ENGAGE_CONVERSATIONS',
-                            ],
-                        },
-                    },
-                });
-            return response.body;
-        } catch (exception) {
-            // How would you prefer to handle this
-            logger.error('Error getting asset', {
-                assetId,
-                userId,
-                companyId,
-                exception,
-            });
-            throw exception;
-        }
-    }
-}
-
-export const assetManagerClient = new AssetManagerClient();

package/src/data-access/http/secrets.js

@@ -1,55 +0,0 @@
-import logger from '../../lib/logger.js';
-import AWS from 'aws-sdk';
-
-class AWS_Secrets {
-    constructor() {
-        const secrets = [
-            'TWITTER_APP_INFO',
-            'IR_API_KEY',
-            'CONVERSATIONS_API_IDENTITY',
-            'SES_ACCESS_KEY',
-        ];
-
-        if (process.env.AWS_ACCESS_KEY_ID_SECRETS) {
-            AWS.config.update({
-                accessKeyId: process.env.AWS_ACCESS_KEY_ID_SECRETS,
-                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY_SECRETS,
-                region: process.env.AWS_DEFAULT_REGION || 'eu-west-1',
-            });
-        } else {
-            AWS.config.update({
-                region: process.env.AWS_DEFAULT_REGION || 'eu-west-1',
-            });
-        }
-
-        const client = new AWS.SecretsManager({ apiVersion: '2017-10-17' });
-        this.secretsLookup = secrets.reduce((secretsLookupPromise, secret) => {
-            return secretsLookupPromise.then((lookup) => {
-                return client
-                    .getSecretValue({ SecretId: secret })
-                    .promise()
-                    .then((data) => {
-                        if (data.SecretString) {
-                            lookup[secret] = JSON.parse(data.SecretString);
-                        }
-
-                        return lookup;
-                    })
-                    .catch((error) => {
-                        logger.error('Error Getting Secret Values', {
-                            secret,
-                            error,
-                        });
-
-                        return lookup;
-                    });
-            });
-        }, Promise.resolve({}));
-    }
-
-    async getSecret(secret) {
-        return (await this.secretsLookup)[secret];
-    }
-}
-
-export const awsSecrets = new AWS_Secrets();

package/src/lib/auth.helpers.js

@@ -1,34 +0,0 @@
-import jwt from 'jsonwebtoken';
-import { awsSecrets } from '../data-access/http/secrets.js';
-import configuration from '../lib/configuration.js';
-
-export async function generateToken(userId, companyId, expiresIn = '5m') {
-    this.privateKey = await awsSecrets
-        .getSecret('CONVERSATIONS_API_IDENTITY')
-        .then((privateKey) => {
-            return Buffer.from(
-                privateKey.CONVERSATIONS_API_IDENTITY,
-                'base64'
-            ).toString('ascii');
-        });
-
-    const token = jwt.sign(
-        {
-            user: {
-                _id: userId,
-                email: 'all.phoenix@meltwater.com',
-            },
-            company: {
-                _id: companyId,
-            },
-        },
-        `${privateKey}`,
-        {
-            algorithm: 'RS256',
-            keyid: `${configuration.get('JWKS_IDENTITY_KID')}`,
-            expiresIn,
-        }
-    );
-
-    return token;
-}