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

package/src/controllers/accounts/controller.js

@@ -0,0 +1,209 @@
+const newError = require('http-errors');
+const { find, map } = require('lodash/fp');
+const {
+  VCLSignatureAlgorithm,
+} = require('@velocitycareerlabs/vnf-nodejs-wallet-sdk');
+const { createCareerWalletAccount, getPersonas } = require('../../fetchers');
+const {
+  validateLogoSize,
+  getCredentialsFromOffers,
+} = require('../../entities');
+
+const accountsController = async (fastify) => {
+  fastify.post(
+    '/',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        body: {
+          $ref: 'https://velocitycareerlabs.io/webwallet-accounts-request.schema.json',
+        },
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-accounts-response.schema.json',
+          },
+          '4xx': { $ref: 'error#' },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos } = req;
+
+      const [existingAccount, personaVcs] = await Promise.all([
+        repos.accounts.findOne({
+          filter: { userId: req.user.sub },
+        }),
+        getPersonaVCs(req.body, req),
+      ]);
+      const initialCredentials = prepareCredentials(personaVcs);
+
+      if (existingAccount != null) {
+        return { account: existingAccount };
+      }
+
+      const {
+        account: {
+          id: careerWalletAccountId,
+          accountType,
+          id_token_sub: userId,
+          didKeyMetadatum = [],
+        },
+        access_token: accessToken,
+      } = await createCareerWalletAccount(req.body, req);
+
+      const accountDidData = await buildDidData(
+        didKeyMetadatum,
+        accessToken,
+        req
+      );
+      const initialCredentialsToInsert = getCredentialsFromOffers(
+        userId,
+        accountDidData.did,
+        initialCredentials
+      );
+      const [account] = await Promise.all([
+        repos.accounts.insert({
+          careerWalletAccountId,
+          accountType,
+          userId,
+          verificationInfo: {
+            createAccountMessageDisplayed: false,
+          },
+          ...accountDidData,
+        }),
+        insertInitialCredentials(initialCredentialsToInsert, req),
+      ]);
+
+      return { account };
+    }
+  );
+
+  fastify.patch(
+    '',
+    {
+      preValidation: [fastify.verifyAccessToken(), validateLogoSize],
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        params: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+          },
+        },
+        body: {
+          $ref: 'https://velocitycareerlabs.io/webwallet-accounts-update-request.schema.json',
+        },
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-accounts-response.schema.json',
+          },
+          '4xx': { $ref: 'error#' },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos, user } = req;
+
+      /**
+       * @type {import('../../entities/accounts/repos/accounts.repo').Account}
+       */
+
+      const existingAccount = await repos.accounts.findOne({
+        filter: { userId: user.sub },
+      });
+
+      if (existingAccount == null) {
+        throw newError.NotFound('Account not found');
+      }
+
+      const account = await repos.accounts.update(
+        existingAccount._id,
+        req.body.account
+      );
+
+      return {
+        account,
+      };
+    }
+  );
+
+  fastify.get(
+    '/test-personas',
+    {
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        response: {
+          200: {
+            type: 'array',
+            items: {
+              $ref: 'https://velocitycareerlabs.io/webwallet-test-persona-response.schema.json',
+            },
+          },
+        },
+      }),
+    },
+    async (req) => {
+      return getPersonas(req);
+    }
+  );
+};
+
+/**
+ * @param {import('../../entities/accounts/repos/accounts.repo').Account['didKeyMetadatum']} didKeyMetadatum
+ * @param {string} accessToken
+ * @param {import('fastify').FastifyRequest} context
+ * @returns {Promise<{did: string, didKeyMetadatum: import('../../entities/accounts/repos/accounts.repo').AccountDidKeyMetadatum[]}>}
+ */
+const buildDidData = async (didKeyMetadatum, accessToken, context) => {
+  const { vclSdk } = context;
+
+  if (didKeyMetadatum.length) {
+    return {
+      did: didKeyMetadatum[0].did,
+      didKeyMetadatum,
+    };
+  }
+
+  const newDidKeyMetadatum = await vclSdk.generateDidJwk({
+    signatureAlgorithm: VCLSignatureAlgorithm.ES256,
+    remoteCryptoServicesToken: accessToken,
+  });
+
+  return {
+    did: newDidKeyMetadatum.did,
+    didKeyMetadatum: [newDidKeyMetadatum],
+  };
+};
+
+const prepareCredentials = map((vc) => ({
+  encodedJwt: vc.jwt_vc,
+}));
+
+const getPersonaVCs = async ({ personaEmail }, context) => {
+  if (personaEmail == null) {
+    return [];
+  }
+  let personas = [];
+  try {
+    personas = await getPersonas(context);
+  } catch (e) {
+    context.log.warn(e);
+    throw newError(502, 'failed to get personas');
+  }
+
+  const persona = find({ email: personaEmail }, personas);
+  if (persona == null) {
+    throw newError(400, 'unrecognized persona');
+  }
+  return persona.vcs;
+};
+
+const insertInitialCredentials = async (credentials, context) => {
+  if (credentials.length <= 0) {
+    return [];
+  }
+  return context.repos.credentials.insertMany(credentials);
+};
+
+module.exports = accountsController;

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

@@ -0,0 +1,6 @@
+module.exports = {
+  ...require('./webwallet-accounts-request.schema'),
+  ...require('./webwallet-accounts-response.schema'),
+  ...require('./webwallet-accounts-update-request.schema'),
+  ...require('./webwallet-test-personas-response.schema'),
+};

package/src/controllers/accounts/schemas/webwallet-accounts-request.schema.js

@@ -0,0 +1,25 @@
+const { accountTypes } = require('../../../entities');
+
+const webWalletAccountsRequestSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-accounts-request.schema.json',
+  title: 'webwallet-accounts-request',
+  description: 'the body of request to retrieve an account',
+  type: 'object',
+  properties: {
+    account: {
+      type: 'object',
+      properties: {
+        accountType: {
+          type: 'string',
+          enum: accountTypes,
+        },
+        id_token: { type: 'string' },
+      },
+      required: ['accountType', 'id_token'],
+    },
+    personaEmail: { type: 'string' },
+  },
+  required: ['account'],
+};
+
+module.exports = { webWalletAccountsRequestSchema };

package/src/controllers/accounts/schemas/webwallet-accounts-response.schema.js

@@ -0,0 +1,72 @@
+const { accountTypes } = require('../../../entities');
+
+const webWalletAccountsResponseSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-accounts-response.schema.json',
+  title: 'webwallet-accounts-response',
+  description: 'the body of response for webwallet create account endpoint',
+  type: 'object',
+  properties: {
+    account: {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        userId: { type: 'string' },
+        accountType: {
+          type: 'string',
+          enum: accountTypes,
+        },
+        did: { type: 'string' },
+        careerWalletAccountId: { type: 'string' },
+        profileName: { type: 'string' },
+        logo: { type: 'string' },
+        verificationInfo: {
+          type: 'object',
+          properties: {
+            createAccountMessageDisplayed: { type: 'boolean' },
+            email: {
+              type: 'object',
+              properties: {
+                status: { type: 'string', enum: ['pending', 'verified'] },
+                codeSentTo: { type: 'string' },
+                codeSentAt: { type: 'string' },
+              },
+              required: ['status'],
+            },
+            phone: {
+              type: 'object',
+              properties: {
+                status: {
+                  type: 'string',
+                  enum: ['pending', 'verified', 'skipped'],
+                },
+                codeSentTo: { type: 'string' },
+                codeSentAt: { type: 'string' },
+              },
+              required: ['status'],
+            },
+          },
+        },
+        linkedin: {
+          type: 'object',
+          properties: {
+            tokenExpiresAt: { type: 'string' },
+          },
+        },
+        createdAt: { type: 'string' },
+        updatedAt: { type: 'string' },
+      },
+      required: [
+        'id',
+        'userId',
+        'did',
+        'careerWalletAccountId',
+        'accountType',
+        'createdAt',
+        'updatedAt',
+      ],
+    },
+  },
+  required: ['account'],
+};
+
+module.exports = { webWalletAccountsResponseSchema };

package/src/controllers/accounts/schemas/webwallet-accounts-update-request.schema.js

@@ -0,0 +1,23 @@
+const webWalletAccountsUpdateRequestSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-accounts-update-request.schema.json',
+  title: 'webwallet-accounts-request',
+  description: 'the body of request to retrieve an account',
+  type: 'object',
+  properties: {
+    account: {
+      type: 'object',
+      properties: {
+        'verificationInfo.createAccountMessageDisplayed': { type: 'boolean' },
+        'verificationInfo.phone.status': {
+          type: 'string',
+          enum: ['pending', 'skipped'],
+        },
+        profileName: { type: 'string' },
+        logo: { type: 'string' },
+      },
+    },
+  },
+  required: ['account'],
+};
+
+module.exports = { webWalletAccountsUpdateRequestSchema };

package/src/controllers/accounts/schemas/webwallet-test-personas-response.schema.js

@@ -0,0 +1,110 @@
+const webwalletTestPersonasResponceSchema = {
+  title: 'persona',
+  $id: 'https://velocitycareerlabs.io/webwallet-test-persona-response.schema.json',
+  type: 'object',
+  properties: {
+    name: {
+      type: 'string',
+      description: 'The name persona',
+    },
+    email: {
+      type: 'string',
+      description: 'email of the persona',
+    },
+    image: {
+      type: 'string',
+      format: 'uri',
+      description: "uri of the persona's image",
+    },
+    vcs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          jwt_vc: {
+            type: 'string',
+            description: 'The verifiable credential encoded as a jwt',
+          },
+          type: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'The list of credential types',
+          },
+          output_descriptors: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                id: {
+                  type: 'string',
+                },
+                schema: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      uri: {
+                        type: 'string',
+                        format: 'uri',
+                      },
+                    },
+                  },
+                },
+                display: {
+                  type: 'object',
+                  additionalProperties: true,
+                },
+              },
+              required: ['id'],
+            },
+          },
+        },
+        required: ['type', 'jwt_vc'],
+      },
+    },
+    did: {
+      type: 'string',
+      description: 'The did of the persona',
+    },
+    kid: {
+      type: 'string',
+      description: 'The kid of the persona',
+    },
+    keyId: {
+      type: 'string',
+      description: 'The keyId of the persona',
+    },
+    publicJwk: {
+      description: 'The public jwk',
+      type: 'object',
+      properties: {
+        crv: {
+          type: 'string',
+        },
+        kid: {
+          type: 'string',
+        },
+        kty: {
+          type: 'string',
+        },
+        x: {
+          type: 'string',
+        },
+        y: {
+          type: 'string',
+        },
+      },
+    },
+    createdAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+    updatedAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+  },
+  required: ['name', 'email', 'vcs'],
+};
+
+module.exports = { webwalletTestPersonasResponceSchema };

package/src/controllers/consent/autohooks.js

@@ -0,0 +1,14 @@
+const { oauthPlugin } = require('@velocitycareerlabs/auth');
+const { webWalletConsentResponseSchema } = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(webWalletConsentResponseSchema)
+    .autoSchemaPreset({
+      tags: ['webwallet'],
+    })
+    .register(oauthPlugin, {
+      domain: fastify.config.auth0Domain,
+      audience: [fastify.config.auth0WebWalletAudience],
+    });
+};

package/src/controllers/consent/controller.js

@@ -0,0 +1,91 @@
+const newError = require('http-errors');
+const {
+  postConsent,
+  getConsentLatest,
+} = require('../../fetchers/career-wallet');
+const { webWalletConsentResponseSchema } = require('./schemas');
+const { WebWalletServerError } = require('../../errors/error-codes');
+
+const consentController = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        tags: ['webwallet'],
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              consent: webWalletConsentResponseSchema,
+            },
+            required: ['consent'],
+          },
+          '4xx': { $ref: 'error#' },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos: { accounts },
+        user,
+      } = req;
+      const account = await accounts.findOne({
+        filter: { userId: user.sub },
+      });
+      if (!account) {
+        throw newError(404, 'Account not found', {
+          errorCode: WebWalletServerError,
+        });
+      }
+
+      const consents = await getConsentLatest(
+        account.careerWalletAccountId,
+        req
+      );
+      reply.status(200);
+      return consents;
+    }
+  );
+
+  fastify.post(
+    '/',
+    {
+      preValidation: fastify.verifyAccessToken(),
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          properties: {
+            version: {
+              type: 'string',
+              pattern: '[0-9]+.[0-9]+',
+            },
+          },
+          required: ['version'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              consent: webWalletConsentResponseSchema,
+            },
+            required: ['consent'],
+          },
+          '4xx': { $ref: 'error#' },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        headers: { authorization },
+        body,
+      } = req;
+      const consents = await postConsent(body, authorization, req);
+
+      reply.status(200);
+      return consents;
+    }
+  );
+};
+
+module.exports = consentController;

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

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

package/src/controllers/consent/schemas/webwallet-consent-response.schema.js

@@ -0,0 +1,23 @@
+const webWalletConsentResponseSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-consent-response.schema.json',
+  title: 'webwallet-consent-response',
+  description: 'the body of response for webwallet get consent latest endpoint',
+  type: 'object',
+  properties: {
+    accountId: {
+      type: 'string',
+    },
+    version: {
+      type: 'string',
+    },
+    createdAt: {
+      type: 'string',
+    },
+    id: {
+      type: 'string',
+    },
+  },
+  required: ['accountId', 'version', 'createdAt', 'id'],
+};
+
+module.exports = { webWalletConsentResponseSchema };

package/src/controllers/credentials/autohooks.js

@@ -0,0 +1,36 @@
+const { oauthPlugin } = require('@velocitycareerlabs/auth');
+const {
+  organizationProfileBaseSchema,
+  organizationProfileSchema,
+  addressSchema,
+  locationSchema,
+} = require('@velocitycareerlabs/common-schemas');
+
+const {
+  webWalletCredentialResponseSchema,
+  webWalletDisplayDescriptorResponseSchema,
+} = require('../../entities');
+
+const {
+  webWalletCredentialsResponseSchema,
+  webWalletCredentialCategoriesResponseSchema,
+} = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(addressSchema)
+    .addSchema(locationSchema)
+    .addSchema(organizationProfileBaseSchema)
+    .addSchema(organizationProfileSchema)
+    .addSchema(webWalletDisplayDescriptorResponseSchema)
+    .addSchema(webWalletCredentialResponseSchema)
+    .addSchema(webWalletCredentialsResponseSchema)
+    .addSchema(webWalletCredentialCategoriesResponseSchema)
+    .autoSchemaPreset({
+      tags: ['webwallet'],
+    })
+    .register(oauthPlugin, {
+      domain: fastify.config.auth0Domain,
+      audience: [fastify.config.auth0WebWalletAudience],
+    });
+};