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

package/src/controllers/api/v0.6/devices/controller.js

@@ -0,0 +1,323 @@
+const newError = require('http-errors');
+const { nanoid } = require('nanoid/non-secure');
+const { isEmpty, last, first, omit, map } = require('lodash/fp');
+const { ObjectId } = require('mongodb');
+const { deviceTypes, deviceOSes } = require('../../../../entities/devices');
+const { accountScopes } = require('../../../../entities');
+
+const deviceController = async (fastify) => {
+  fastify.post(
+    '/',
+    {
+      // preHandler: fastify.verifyAdmin, TODO use another token
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          properties: {
+            deviceId: {
+              minLength: 1,
+              type: 'string',
+            },
+            deviceType: {
+              type: 'string',
+              enum: deviceTypes,
+            },
+            deviceOS: {
+              type: 'string',
+              enum: deviceOSes,
+            },
+            pushActivated: {
+              type: 'boolean',
+            },
+          },
+          required: ['deviceId', 'deviceType', 'deviceOS'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              deviceId: { type: 'string' },
+              deviceType: { type: 'string' },
+              deviceOS: { type: 'string' },
+              pushActivated: { type: 'boolean' },
+              pushToken: { type: 'string' },
+            },
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        body,
+        repos: { devices },
+      } = req;
+      return devices.findOrInsert(
+        {
+          ...body,
+          pushToken: nanoid(),
+        },
+        ['deviceId']
+      );
+    }
+  );
+  fastify.get(
+    '/',
+    {
+      preHandler: fastify.verifyAdmin,
+      security: [{ bearerAuth: [] }],
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'array',
+            items: { $ref: 'https://velocitycareerlabs.io/device.json#' },
+          },
+        },
+      }),
+    },
+    async (req) => req.repos.devices.find({})
+  );
+  fastify.get(
+    '/:deviceId',
+    {
+      onRequest: fastify.verifyCareerWalletAccessToken([accountScopes.account]),
+      schema: fastify.autoSchema({
+        security: [{ bearerAuth: [accountScopes.account] }],
+        params: {
+          type: 'object',
+          properties: {
+            deviceId: { type: 'string' },
+          },
+        },
+        response: {
+          200: { $ref: 'https://velocitycareerlabs.io/device.json#' },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        repos: { devices },
+        params: { deviceId },
+      } = req;
+      return devices.findOne({ filter: { deviceId } });
+    }
+  );
+
+  fastify.get(
+    '/:deviceId/pushes',
+    {
+      onRequest: fastify.verifyCareerWalletAccessToken([accountScopes.inbox]),
+      schema: fastify.autoSchema({
+        security: [{ bearerAuth: [accountScopes.inbox] }],
+        params: {
+          type: 'object',
+          properties: {
+            deviceId: { type: 'string' },
+          },
+        },
+        query: {
+          pushSeqId: { type: 'string' },
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              nextPushSeqId: { type: 'string' },
+              pushes: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    _id: {
+                      type: 'string',
+                    },
+                    id: {
+                      type: 'string',
+                    },
+                    data: {
+                      type: 'object',
+                      properties: {
+                        notificationId: {
+                          type: 'string',
+                        },
+                        count: {
+                          type: 'string',
+                        },
+                        notificationType: {
+                          type: 'string',
+                        },
+                        exchangeId: {
+                          type: 'string',
+                        },
+                        credentialId: {
+                          type: 'string',
+                        },
+                        credentialTypes: {
+                          type: 'string',
+                        },
+                        replacementCredentialType: {
+                          type: 'string',
+                        },
+                        issuer: {
+                          type: 'string',
+                        },
+                      },
+                    },
+                    notification: {
+                      type: 'object',
+                      properties: {
+                        title: {
+                          type: 'string',
+                        },
+                        body: {
+                          type: 'string',
+                        },
+                        icon: {
+                          type: 'string',
+                        },
+                      },
+                    },
+                  },
+                  required: ['id'],
+                },
+              },
+            },
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        query: { pushSeqId },
+        repos: { notifications: notificationsRepo },
+        params: { deviceId },
+      } = req;
+      const pushes = await notificationsRepo.find({
+        filter: {
+          deviceId,
+          ...(pushSeqId && { _id: { $gt: new ObjectId(pushSeqId) } }),
+        },
+        orderBy: [['_id', 'ascending']],
+      });
+      const nextPushSeqId = last(pushes)?._id;
+
+      return {
+        pushes: map(
+          (push) => omit(['createdAt', 'deviceId', 'linkedDevice'])(push),
+          pushes
+        ),
+        nextPushSeqId,
+      };
+    }
+  );
+
+  fastify.delete(
+    '/:deviceId',
+    {
+      onRequest: fastify.verifyCareerWalletAccessToken([
+        accountScopes.account,
+        accountScopes.inbox,
+      ]),
+      schema: fastify.autoSchema({
+        security: [
+          { bearerAuth: [accountScopes.account, accountScopes.inbox] },
+        ],
+        params: {
+          type: 'object',
+          properties: {
+            deviceId: { type: 'string' },
+          },
+          required: ['deviceId'],
+        },
+        response: {
+          204: { type: 'null' },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos: { devices, notifications },
+        params: { deviceId },
+      } = req;
+      const deletedIds = await devices.delUsingFilter({
+        filter: { deviceId },
+      });
+
+      if (isEmpty(deletedIds)) {
+        throw newError.NotFound(`Device ${deviceId} not found`);
+      }
+      await notifications.delUsingFilter({
+        filter: { linkedDevice: { $in: deletedIds } },
+      });
+
+      reply.code(204);
+    }
+  );
+
+  fastify.put(
+    '/:deviceId',
+    {
+      onRequest: fastify.verifyCareerWalletAccessToken([accountScopes.account]),
+      schema: fastify.autoSchema({
+        security: [{ bearerAuth: [accountScopes.account] }],
+        body: {
+          type: 'object',
+          properties: {
+            deviceId: {
+              minLength: 1,
+              type: 'string',
+            },
+            deviceType: {
+              type: 'string',
+              enum: deviceTypes,
+            },
+            deviceOS: {
+              type: 'string',
+              enum: deviceOSes,
+            },
+            pushActivated: {
+              type: 'boolean',
+            },
+          },
+          required: ['deviceId'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              deviceId: { type: 'string' },
+              deviceType: { type: 'string' },
+              deviceOS: { type: 'string' },
+              pushActivated: { type: 'boolean' },
+            },
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        body,
+        repos: { devices: devicesRepo, notifications: notificationsRepo },
+        params: { deviceId },
+      } = req;
+
+      const device = first(
+        await devicesRepo.updateUsingFilter({ filter: { deviceId } }, body)
+      );
+
+      if (!device) {
+        throw new newError.NotFound('Device not found.');
+      }
+
+      if (deviceId !== body.deviceId) {
+        await notificationsRepo.updateUsingFilter(
+          { filter: { linkedDevice: device._id } },
+          { deviceId: body.deviceId }
+        );
+      }
+
+      return device;
+    }
+  );
+};
+
+module.exports = deviceController;

package/src/controllers/api/v0.6/devices/repo.js

@@ -0,0 +1,27 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+module.exports = (app, options, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'devices',
+      entityName: 'devices',
+      defaultProjection: {
+        _id: 1,
+        deviceId: 1,
+        accountId: 1,
+        deviceType: 1,
+        deviceOS: 1,
+        pushToken: 1,
+        pushActivated: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};

package/src/controllers/api/v0.6/devices/schemas/device.schema.json

@@ -0,0 +1,43 @@
+{
+  "title": "device",
+  "$id": "https://velocitycareerlabs.io/device.json",
+  "description": "payload for device",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "accountId": {
+      "type": "string"
+    },
+    "deviceId": {
+      "type": "string"
+    },
+    "deviceType": {
+      "type": "string"
+    },
+    "deviceOS": {
+      "type": "string"
+    },
+    "pushToken": {
+      "type": "string"
+    },
+    "pushActivated": {
+      "type": "boolean"
+    },
+    "createdAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "updatedAt": {
+      "type": "string",
+      "format": "date-time"
+    }
+  },
+  "required": [
+    "id",
+    "deviceId",
+    "createdAt",
+    "updatedAt"
+  ]
+}

package/src/controllers/api/v0.6/devices/schemas/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  deviceSchema: require('./device.schema.json'),
+};

package/src/controllers/api/v0.6/feedback/controller.js

@@ -0,0 +1,24 @@
+const { newFeedbackSchema } = require('./schemas');
+const { generateFeedbackEmail } = require('../../../../entities');
+
+const controller = async (fastify) => {
+  const { sendEmail } = fastify;
+  fastify.post(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        body: newFeedbackSchema,
+        response: {
+          204: { type: 'null', description: 'Feedback submitted' },
+        },
+      }),
+    },
+    async (req, rep) => {
+      const { body } = req;
+      await sendEmail(generateFeedbackEmail(body, req));
+      return rep.code(204).send();
+    }
+  );
+};
+
+module.exports = controller;

package/src/controllers/api/v0.6/feedback/schemas/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  newFeedbackSchema: require('./new-feedback.schema'),
+};

package/src/controllers/api/v0.6/feedback/schemas/new-feedback.schema.js

@@ -0,0 +1,47 @@
+module.exports = {
+  type: 'object',
+  properties: {
+    accountId: {
+      type: 'string',
+      description: 'account id of the user',
+    },
+    feedback: {
+      type: 'string',
+      description: 'the feedback of the user',
+    },
+    errorCode: {
+      type: 'string',
+      description: 'error code they have received (if applicable)',
+    },
+    appVersion: {
+      type: 'string',
+      description: 'the version they are running',
+    },
+    deviceManufacturer: {
+      type: 'string',
+      description: 'device manufacturer',
+    },
+    deviceModel: {
+      type: 'string',
+      description: 'the device model they are running',
+    },
+    deviceOS: {
+      type: 'string',
+      description: 'the OS & Version they are running',
+    },
+    ip: {
+      type: 'string',
+      description: 'the ip address they are using',
+    },
+  },
+  required: [
+    'accountId',
+    'feedback',
+    'appVersion',
+    'deviceManufacturer',
+    'deviceModel',
+    'deviceOS',
+    'ip',
+  ],
+  additionalProperties: false,
+};

package/src/controllers/api/v0.6/jwt/autohooks.js

@@ -0,0 +1,10 @@
+const { verifyAccessTokenPlugin } = require('../../../../plugins');
+const { accountScopes } = require('../../../../entities');
+
+const autohooks = async (fastify) => {
+  fastify
+    .register(verifyAccessTokenPlugin)
+    .autoSchemaPreset({ security: [{ bearerAuth: [accountScopes.jwt] }] });
+};
+
+module.exports = autohooks;

package/src/controllers/api/v0.6/jwt/controller.js

@@ -0,0 +1,44 @@
+const { initKmsClient } = require('@velocitycareerlabs/aws-clients');
+const { jwtSign, jwkFromStringified } = require('@velocitycareerlabs/jwt');
+const { jwtRequest, jwtResponse } = require('./schemas');
+const { accountScopes, getKeyPair } = require('../../../../entities');
+
+const controller = async (fastify) => {
+  const awsKmsClient = initKmsClient(fastify.config);
+  fastify.post(
+    '/sign',
+    {
+      onRequest: [fastify.verifyCareerWalletAccessToken([accountScopes.jwt])],
+      schema: fastify.autoSchema({
+        tags: ['careerwallet'],
+        body: jwtRequest,
+        response: {
+          200: jwtResponse,
+        },
+      }),
+    },
+    async (req) => {
+      const { body } = req;
+      const { header = {}, payload, options } = body;
+
+      const keyPair = await getKeyPair(options, req);
+
+      const decryptedPrivateKey = await awsKmsClient.decrypt(
+        Buffer.from(keyPair.encryptedPrivateKey.buffer)
+      );
+      const jwkPrivate = jwkFromStringified(
+        decryptedPrivateKey.Plaintext.toString()
+      );
+      const compactJwt = await jwtSign(payload, jwkPrivate, {
+        ...header,
+        alg: jwkPrivate.crv === 'P-256' ? 'ES256' : 'ES256K',
+      });
+
+      return {
+        compactJwt,
+      };
+    }
+  );
+};
+
+module.exports = controller;

package/src/controllers/api/v0.6/jwt/schemas/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('./jwt-request.schema'),
+  ...require('./jwt-response.schema'),
+};

package/src/controllers/api/v0.6/jwt/schemas/jwt-request.schema.js

@@ -0,0 +1,40 @@
+const jwtRequest = {
+  title: 'jwt-request',
+  $id: 'https://velocitycareerlabs.io/jwt-request.schema.json',
+  description: 'jwt request schema',
+  type: 'object',
+  properties: {
+    header: {
+      type: 'object',
+    },
+    payload: {
+      type: 'object',
+    },
+    options: {
+      type: 'object',
+      oneOf: [
+        {
+          required: ['kid'],
+          properties: {
+            kid: {
+              type: 'string',
+              minLength: 1,
+            },
+          },
+        },
+        {
+          required: ['keyId'],
+          properties: {
+            keyId: {
+              type: 'string',
+              minLength: 1,
+            },
+          },
+        },
+      ],
+    },
+  },
+  required: ['payload', 'options'],
+};
+
+module.exports = { jwtRequest };

package/src/controllers/api/v0.6/jwt/schemas/jwt-response.schema.js

@@ -0,0 +1,14 @@
+const jwtResponse = {
+  title: 'jwt-response',
+  $id: 'https://velocitycareerlabs.io/jwt-response.schema.json',
+  description: 'jwt response schema',
+  type: 'object',
+  properties: {
+    compactJwt: {
+      type: 'string',
+    },
+  },
+  required: ['compactJwt'],
+};
+
+module.exports = { jwtResponse };