@velocitycareerlabs/server-webwallet 1.25.0-dev-build.12642c864

package/src/controllers/linkedin/controller.js

@@ -0,0 +1,276 @@
+const {
+  getLinkedInAccessToken,
+  getLinkedInUserId,
+  getLinkedInUserEmail,
+  registerImageToUpload,
+  uploadImageToLinkedin,
+  createLinkedinPost,
+  revokeLinkedinAccess,
+} = require('../../fetchers/linkedin');
+
+/**
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+const linkedinController = async (fastify) => {
+  fastify.post(
+    '/authorize',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        body: {
+          type: 'object',
+          properties: {
+            code: { type: 'string' },
+            redirectUri: { type: 'string' },
+          },
+          required: ['code'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              expiresIn: { type: 'number' },
+            },
+          },
+          400: {
+            type: 'object',
+            properties: {
+              error: { type: 'string' },
+            },
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const { access_token: accessToken, expires_in: expiresIn } =
+        await getLinkedInAccessToken(
+          { code: req.body.code, redirectUri: req.body.redirectUri || '' },
+          req
+        );
+
+      if (!accessToken || !expiresIn) {
+        reply.code(400);
+        return { error: 'Failed to get LinkedIn access token' };
+      }
+
+      await req.repos.accounts.updateUsingFilter(
+        {
+          filter: {
+            userId: req.user.sub,
+          },
+        },
+        {
+          linkedin: {
+            accessToken,
+            tokenExpiresAt: new Date(new Date().getTime() + expiresIn * 1000),
+          },
+        }
+      );
+
+      reply.code(200);
+      return { expiresIn };
+    }
+  );
+
+  fastify.get(
+    '/me',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-linkedin-me-response.schema.json',
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos: { accounts },
+        user,
+      } = req;
+
+      const account = await accounts.findOne({
+        filter: { userId: user.sub },
+      });
+
+      if (!account.linkedin?.accessToken) {
+        reply.code(204);
+        return {};
+      }
+      try {
+        const {
+          id: linkedinUserId,
+          localizedLastName,
+          localizedFirstName,
+        } = await getLinkedInUserId(account.linkedin.accessToken, req);
+
+        const { elements } = await getLinkedInUserEmail(
+          account.linkedin.accessToken,
+          req
+        );
+        reply.code(200);
+
+        return {
+          userId: linkedinUserId,
+          userName: `${localizedFirstName} ${localizedLastName}`,
+          userEmail: elements[0]['handle~'].emailAddress,
+        };
+      } catch (error) {
+        if (error?.response.statusCode === 401) {
+          await accounts.updateUsingFilter(
+            {
+              filter: { userId: user.sub },
+            },
+            {
+              linkedin: {},
+            }
+          );
+        }
+        throw error;
+      }
+    }
+  );
+
+  fastify.post(
+    '/revoke',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos: { accounts },
+        user,
+      } = req;
+
+      const { linkedin } = await accounts.findOne({
+        filter: { userId: user.sub },
+      });
+      if (linkedin?.accessToken) {
+        await revokeLinkedinAccess(linkedin.accessToken, req);
+        await accounts.updateUsingFilter(
+          {
+            filter: { userId: user.sub },
+          },
+          {
+            linkedin: {},
+          }
+        );
+      }
+      reply.code(204);
+    }
+  );
+
+  fastify.post(
+    '/feed',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          patternProperties: {
+            'message[0-9]+': { type: 'string' },
+            'logo[0-9]+': { type: 'object' },
+            'credential[0-9]+': { type: 'string' },
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos: { accounts },
+        user,
+      } = req;
+
+      const posts = [];
+      Object.keys(req.body).forEach((key) => {
+        const [prop, index] = key.split(/[[\]]/).filter(Boolean);
+        if (!posts[index]) {
+          // eslint-disable-next-line better-mutation/no-mutation
+          posts[index] = {};
+        }
+        // eslint-disable-next-line better-mutation/no-mutation
+        posts[index][prop] = req.body[key];
+      });
+
+      const requiredProps = ['message', 'logo', 'credential'];
+      posts.forEach((post, i) => {
+        requiredProps.forEach((prop) => {
+          if (!Object.prototype.propertyIsEnumerable.call(post, prop)) {
+            reply
+              .code(400)
+              .send({ error: `Missing required property: ${prop}${i}` });
+          }
+        });
+      });
+      let linkedinAccessToken;
+      try {
+        const {
+          linkedin: { accessToken },
+        } = await accounts.findOne({
+          filter: { userId: user.sub },
+        });
+        linkedinAccessToken = accessToken;
+      } catch (error) {
+        reply.code(400);
+        return { error: 'LinkedIn access token not found' };
+      }
+
+      try {
+        const { id: linkedinUserId } = await getLinkedInUserId(
+          linkedinAccessToken,
+          req
+        );
+
+        const linkedinPosts = await Promise.all(
+          posts.map(async (params) => {
+            let imageData;
+            if (params.logo) {
+              const uploadLinkData = await registerImageToUpload(
+                { accessToken: linkedinAccessToken, linkedinUserId },
+                req
+              );
+
+              imageData = {
+                uploadUrl:
+                  uploadLinkData.value.uploadMechanism[
+                    'com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest'
+                  ].uploadUrl,
+                asset: uploadLinkData.value.asset,
+              };
+
+              await uploadImageToLinkedin({
+                accessToken: linkedinAccessToken,
+                file: params.logo,
+                uploadUrl: imageData.uploadUrl,
+              });
+            }
+            return createLinkedinPost(
+              {
+                accessToken: linkedinAccessToken,
+                linkedinUserId,
+                text: params.message,
+                asset: imageData?.asset,
+              },
+              req
+            );
+          })
+        );
+
+        reply.code(201);
+
+        return linkedinPosts;
+      } catch (error) {
+        reply.code(400);
+        return { error: error.message };
+      }
+    }
+  );
+};
+
+module.exports = linkedinController;

package/src/controllers/linkedin/schemas/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./webwallet-linkedin-me-response.schema'),
+};

package/src/controllers/linkedin/schemas/webwallet-linkedin-me-response.schema.js

@@ -0,0 +1,14 @@
+const webWalletLinkedinMeResponseSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-linkedin-me-response.schema.json',
+  title: 'webwallet-linkedin-me-response',
+  description: 'the body of response for webwallet linkedin me endpoint',
+  type: 'object',
+  properties: {
+    userId: { type: 'string' },
+    userName: { type: 'string' },
+    userEmail: { type: 'string' },
+  },
+  required: ['userId', 'userEmail', 'userName'],
+};
+
+module.exports = { webWalletLinkedinMeResponseSchema };

package/src/controllers/root/controller.js

@@ -0,0 +1,29 @@
+const rootRoutes = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: {
+        description: 'Healthcheck and version info',
+        responses: {
+          200: {
+            description: 'Successful response',
+            content: { 'text/plain': { schema: { type: 'string' } } },
+          },
+        },
+        tags: ['healthchecks'],
+      },
+    },
+    async (_res, reply) => {
+      reply
+        .status(200)
+        .send(
+          `Welcome to Webwallet Server\nVersion: ${fastify.config.version}\n`
+        );
+    }
+  );
+};
+
+// eslint-disable-next-line better-mutation/no-mutation
+rootRoutes.prefixOverride = '';
+
+module.exports = rootRoutes;

package/src/entities/accounts/constants.js

@@ -0,0 +1,5 @@
+const accountTypes = ['perm', 'temp'];
+
+module.exports = {
+  accountTypes,
+};

package/src/entities/accounts/domains/extract-auth0-id-token-or-access-token.js

@@ -0,0 +1,22 @@
+const newError = require('http-errors');
+
+const extractAuth0IdTokenOrAccessToken = (req) => {
+  const {
+    body: {
+      account: { id_token: auth0IdToken },
+    },
+    headers: { authorization = '' },
+  } = req;
+
+  const [, auth0AccessToken] = authorization.split(' ');
+
+  if (!auth0IdToken && !auth0AccessToken) {
+    throw new newError.Unauthorized('No authorization token provided');
+  }
+
+  return auth0IdToken || auth0AccessToken;
+};
+
+module.exports = {
+  extractAuth0IdTokenOrAccessToken,
+};

package/src/entities/accounts/domains/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./validate-account-permissions'),
+  ...require('./validate-logo-size'),
+  ...require('./extract-auth0-id-token-or-access-token'),
+};

package/src/entities/accounts/domains/validate-account-permissions.js

@@ -0,0 +1,36 @@
+const newError = require('http-errors');
+const { get, includes } = require('lodash/fp');
+const { WebWalletServerError } = require('../../../errors/error-codes');
+
+/**
+ * @param {import("../repos/accounts.repo").Account} account
+ * @throws {Error}
+ */
+const validateAccountPermissions = (account) => {
+  const emailStatus = get('verificationInfo.email.status', account);
+  const phoneStatus = get('verificationInfo.phone.status', account);
+
+  if (emailStatus !== 'verified') {
+    throw newError(403, 'Email verification is required.', {
+      errorCode: WebWalletServerError,
+    });
+  }
+
+  if (!includes(phoneStatus, ['skipped', 'verified'])) {
+    throw newError(403, 'Phone verification is required.', {
+      errorCode: WebWalletServerError,
+    });
+  }
+
+  if (!account.profileName) {
+    throw newError(403, 'Profile is not completed.', {
+      errorCode: WebWalletServerError,
+    });
+  }
+
+  return true;
+};
+
+module.exports = {
+  validateAccountPermissions,
+};

package/src/entities/accounts/domains/validate-logo-size.js

@@ -0,0 +1,25 @@
+const newError = require('http-errors');
+
+/**
+ * @param {import('fastify').FastifyRequest} request
+ */
+const validateLogoSize = async (request) => {
+  const { logo } = request.body.account;
+
+  if (!logo) {
+    return;
+  }
+
+  const buffer = Buffer.from(logo, 'base64');
+
+  const maxSizeInBytes = 100 * 1024; // 100 KB
+  if (buffer.length > maxSizeInBytes) {
+    throw newError.BadRequest(
+      'Logo size is too large. Maximum size is 100 KB.'
+    );
+  }
+};
+
+module.exports = {
+  validateLogoSize,
+};

package/src/entities/accounts/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  accountsRepoPlugin: require('./repos/accounts.repo'),
+  ...require('./constants'),
+  ...require('./domains'),
+};

package/src/entities/accounts/repos/accounts.repo.js

@@ -0,0 +1,63 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+/**
+ * @typedef {Object} Account
+ * @property {string} id
+ * @property {string} userId
+ * @property {string} did
+ * @property {Object} didKeyMetadatum
+ * @property {string} careerWalletAccountId
+ * @property {string} accountType
+ * @property {string} profileName
+ * @property {string} logo
+ * @property {Object} [verificationInfo]
+ * @property {boolean} verificationInfo.createAccountMessageDisplayed
+ * @property {Object} [verificationInfo.email]
+ * @property {string} verificationInfo.email.status
+ * @property {string} verificationInfo.email.codeSentTo
+ * @property {string} verificationInfo.email.codeSentAt
+ * @property {Object} [verificationInfo.phone]
+ * @property {string} verificationInfo.phone.status
+ * @property {string} verificationInfo.phone.codeSentTo
+ * @property {string} verificationInfo.phone.codeSentAt
+ * @property {Object} linkedin
+ * @property {string} accessToken
+ * @property {string} tokenExpiresAt
+ * @property {string} createdAt
+ * @property {string} updatedAt
+ */
+module.exports = (app, _, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'accounts',
+      entityName: 'accounts',
+      defaultProjection: {
+        _id: 1,
+        userId: 1,
+        did: 1,
+        didKeyMetadatum: 1,
+        careerWalletAccountId: 1,
+        accountType: 1,
+        profileName: 1,
+        logo: 1,
+        consent: 1,
+        'verificationInfo.createAccountMessageDisplayed': 1,
+        'verificationInfo.email.status': 1,
+        'verificationInfo.email.codeSentTo': -1,
+        'verificationInfo.email.codeSentAt': 1,
+        'verificationInfo.phone.status': 1,
+        'verificationInfo.phone.codeSentTo': -1,
+        'verificationInfo.phone.codeSentAt': 1,
+        linkedin: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};

package/src/entities/credentials/domains/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./offer-to-credential-mongo-dto'),
+};

package/src/entities/credentials/domains/offer-to-credential-mongo-dto.js

@@ -0,0 +1,43 @@
+const offerToCredentialMongoDTO = (auth0UserId, userDid, credential) => {
+  const {
+    vc: {
+      type,
+      id: did,
+      credentialStatus,
+      linkCodeCommitment,
+      issuer,
+      contentHash,
+      credentialSchema,
+      vnfProtocolVersion,
+      '@context': context,
+      credentialSubject,
+      relatedResource,
+    },
+    jti,
+    iss,
+    encodedCredential,
+  } = credential;
+
+  return {
+    type,
+    did,
+    auth0UserId,
+    userDid,
+    credentialStatus,
+    linkCodeCommitment,
+    issuer,
+    relatedResource,
+    contentHash,
+    credentialSchema,
+    vnfProtocolVersion,
+    context,
+    credentialSubject,
+    jti,
+    iss,
+    encodedCredential,
+  };
+};
+
+module.exports = {
+  offerToCredentialMongoDTO,
+};

package/src/entities/credentials/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  credentialsRepoPlugin: require('./repos/credentials.repo'),
+  ...require('./domains'),
+  ...require('./schemas'),
+  ...require('./orchestrators'),
+};

package/src/entities/credentials/orchestrators/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./load-additional-render-info'),
+};

package/src/entities/credentials/orchestrators/load-additional-render-info.js

@@ -0,0 +1,65 @@
+const { flow, map, uniq, fromPairs, compact } = require('lodash/fp');
+
+const {
+  VCLOrganizationsSearchDescriptor,
+  VCLFilter,
+} = require('@velocitycareerlabs/vnf-nodejs-wallet-sdk');
+const {
+  normalizeJsonSchemaName,
+} = require('@velocitycareerlabs/common-functions');
+const { getCredentialDisplaySchema } = require('../../../fetchers/lib-api');
+
+const loadAdditionalRenderInfo = async (credentials, context) => {
+  return {
+    issuers: await loadIssuersInfo(credentials, context),
+    displayDescriptors: await loadCredentialTypeDisplaySchemas(
+      credentials,
+      context
+    ),
+  };
+};
+
+const loadIssuersInfo = async (credentials, context) => {
+  const issuerIds = flow(map('issuer.id'), uniq)(credentials);
+
+  const issuers = await Promise.all(
+    issuerIds.map(async (id) => {
+      const organizations = await context.vclSdk.searchForOrganizations(
+        new VCLOrganizationsSearchDescriptor(new VCLFilter(id))
+      );
+      return organizations.all?.[0]?.payload;
+    })
+  );
+
+  return issuers.reduce((acc, issuer, index) => {
+    acc[issuerIds[index]] = issuer;
+    return acc;
+  }, {});
+};
+
+const getCredentialSchemaByType = async (credentialTypes, context) => {
+  const schemas = await Promise.all(
+    map(
+      (type) =>
+        getCredentialDisplaySchema(normalizeJsonSchemaName(type), context).then(
+          (data) => [type, data]
+        ),
+      credentialTypes
+    )
+  );
+
+  return fromPairs(schemas);
+};
+
+const loadCredentialTypeDisplaySchemas = async (credentials, context) => {
+  const credentialTypes = flow(map('type.0'), compact, uniq)(credentials);
+
+  return getCredentialSchemaByType(credentialTypes, context);
+};
+
+module.exports = {
+  loadAdditionalRenderInfo,
+  loadIssuersInfo,
+  loadCredentialTypeDisplaySchemas,
+  getCredentialSchemaByType,
+};