@verii/server-mockvendor 1.0.0-pre.1752076816

package/src/controllers/api/create_jwk/schemas/jwk-response.schema.js

@@ -0,0 +1,33 @@
+const jwkResponse = {
+  title: 'jwk-response',
+  $id: 'https://velocitycareerlabs.io/jwk-response.schema.json',
+  description: 'jwk response schema',
+  type: 'object',
+  properties: {
+    jwk: {
+      type: 'object',
+      required: ['kty'],
+      properties: {
+        kty: { type: 'string' },
+        use: { type: 'string' },
+        key_ops: { type: 'string' },
+        x5u: { type: 'string' },
+        x5c: { type: 'string' },
+        x5t: { type: 'string' },
+        'x5t#S256': { type: 'string' },
+        alg: { type: 'string' },
+        kid: { type: 'string' },
+        exp: { type: 'string' },
+        crv: { type: 'string' },
+        y: { type: 'string' },
+        x: { type: 'string' },
+        n: { type: 'string' },
+        e: { type: 'string' },
+      },
+    },
+    keyId: { type: 'string' },
+  },
+  required: ['jwk', 'keyId'],
+};
+
+module.exports = { jwkResponse };

package/src/controllers/api/credential-submissions/controller.js

@@ -0,0 +1,59 @@
+const { isEmpty, set } = require('lodash/fp');
+const { endOfDay, startOfDay } = require('date-fns/fp');
+
+module.exports = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        query: {
+          type: 'object',
+          properties: {
+            vendorDisclosureId: {
+              type: 'string',
+              description:
+                '(optional) the vendor disclosure id to get submissions for',
+            },
+            dateFrom: {
+              type: 'string',
+              format: 'date',
+              description:
+                '(optional) only get submissions for dates on or after this date',
+            },
+            dateUntil: {
+              type: 'string',
+              format: 'date',
+              description:
+                '(optional) only get submissions for dates on or before this date',
+            },
+          },
+        },
+      },
+    },
+    async ({ repos, query }) => {
+      let filter = {};
+      if (!isEmpty(query.vendorDisclosureId)) {
+        filter = set('vendorDisclosureId', query.vendorDisclosureId, filter);
+      }
+      if (!isEmpty(query.dateFrom)) {
+        filter = set(
+          'createdAt.$gte',
+          startOfDay(new Date(query.dateFrom)),
+          filter
+        );
+      }
+      if (!isEmpty(query.dateUntil)) {
+        filter = set(
+          'createdAt.$lte',
+          endOfDay(new Date(query.dateFrom)),
+          filter
+        );
+      }
+      return repos.credentialSubmissions.find({
+        filter,
+        sort: { createdAt: -1 },
+      });
+    }
+  );
+};

package/src/controllers/api/credential-submissions/repo.js

@@ -0,0 +1,16 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+module.exports = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'credentialSubmissions',
+      entityName: 'credentialSubmission',
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};

package/src/controllers/api/identifications/controller.js

@@ -0,0 +1,67 @@
+const { isEmpty, set } = require('lodash/fp');
+const { endOfDay, startOfDay } = require('date-fns/fp');
+
+module.exports = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        query: {
+          type: 'object',
+          properties: {
+            dateFrom: {
+              type: 'string',
+              format: 'date',
+              description:
+                '(optional) only get submissions for dates on or after this date',
+            },
+            dateUntil: {
+              type: 'string',
+              format: 'date',
+              description:
+                '(optional) only get submissions for dates on or before this date',
+            },
+          },
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              identifications: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  additionalProperties: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    async ({ repos, query }) => {
+      let filter = {};
+      if (!isEmpty(query.dateFrom)) {
+        filter = set(
+          'createdAt.$gte',
+          startOfDay(new Date(query.dateFrom)),
+          filter
+        );
+      }
+      if (!isEmpty(query.dateUntil)) {
+        filter = set(
+          'createdAt.$lte',
+          endOfDay(new Date(query.dateFrom)),
+          filter
+        );
+      }
+      const identifications = await repos.identifications.find({
+        filter,
+        sort: { createdAt: -1 },
+      });
+
+      return { identifications };
+    }
+  );
+};

package/src/controllers/api/identifications/repo.js

@@ -0,0 +1,22 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+module.exports = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'identifications',
+      entityName: 'identification',
+      extensions: [autoboxIdsExtension],
+      mutable: false,
+      defaultProjection: {
+        _id: 1,
+        identification: 1,
+        createdAt: 1,
+      },
+    },
+    app
+  );
+};

package/src/controllers/api/issuing-exchanges/controller.js

@@ -0,0 +1,218 @@
+const { map, omit, castArray, isNil, omitBy } = require('lodash/fp');
+const { nanoid } = require('nanoid');
+const {
+  submitCreateExchange,
+  submitOffer,
+  completeSubmitOffer,
+  getExchangeQrCode,
+} = require('./fetchers');
+
+const createExchange = async (tenantDID, context) => {
+  const exchange = await submitCreateExchange(tenantDID, 'ISSUING', context);
+
+  await context.repos.issuingExchanges.insert({
+    exchangeId: exchange.id,
+    tenantDID,
+  });
+
+  return exchange.id;
+};
+
+const prepOffer = (exchangeId, tenantDID) => (offer) => ({
+  offerId: nanoid(),
+  exchangeId,
+  issuer: { id: tenantDID },
+  ...offer,
+});
+
+const createCredentialAgentOffers = async (
+  offers,
+  tenantDID,
+  exchangeId,
+  context
+) => {
+  const { repos } = context;
+
+  const insertedOffers = await repos.offers.insertMany(
+    map(prepOffer(exchangeId, tenantDID), offers)
+  );
+
+  await Promise.all(
+    map(
+      (offer) =>
+        submitOffer(
+          {
+            offer: omit(['id', 'exchangeId'], offer),
+            exchangeId,
+            tenantDID,
+          },
+          context
+        ),
+      insertedOffers
+    )
+  );
+  await completeSubmitOffer({ exchangeId, tenantDID }, context);
+  return { exchangeId, tenantDID, offers: insertedOffers };
+};
+
+const controller = async (fastify) => {
+  fastify.get(
+    '/:tenantDID',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        params: {
+          type: 'object',
+          properties: {
+            tenantDID: { type: 'string' },
+          },
+          required: ['tenantDID'],
+        },
+        query: {
+          type: 'object',
+          properties: {
+            exchangeId: { type: 'string' },
+            issuer: { type: 'string' },
+            vendorUserId: { type: 'string' },
+            date: { type: 'string', format: 'date-time' },
+            credentialTypes: {
+              oneOf: [
+                { type: 'string' },
+                { type: 'array', items: { type: 'string' } },
+              ],
+            },
+          },
+        },
+      },
+    },
+    async (req) => {
+      const {
+        query: { credentialTypes, exchangeId, vendorUserId, date },
+        params: { tenantDID },
+        repos,
+      } = req;
+      return repos.issuingExchanges.find({
+        filter: omitBy(isNil, {
+          exchangeId,
+          issuer: { id: tenantDID },
+          vendorUserId,
+          createdAt: date ? { $gte: new Date(date) } : undefined,
+          type: {
+            $in: castArray(credentialTypes),
+          },
+        }),
+      });
+    }
+  );
+  fastify.post(
+    '/:tenantDID/:exchangeId/push-offers',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        params: {
+          type: 'object',
+          properties: {
+            exchangeId: { type: 'string' },
+            tenantDID: { type: 'string' },
+          },
+          required: ['tenantDID', 'exchangeId'],
+        },
+        body: {
+          type: 'object',
+          required: ['offer'],
+          properties: {
+            offer: {
+              oneOf: [
+                {
+                  $ref: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json#',
+                },
+                {
+                  type: 'array',
+                  items: {
+                    $ref: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json#',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      },
+    },
+    async (req) => {
+      const {
+        body: { offer },
+        params: { exchangeId, tenantDID },
+      } = req;
+      const { offers } = await createCredentialAgentOffers(
+        castArray(offer),
+        tenantDID,
+        exchangeId,
+        req
+      );
+
+      return offers;
+    }
+  );
+
+  fastify.post(
+    '/:tenantDID/create-qrcode',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        params: {
+          type: 'object',
+          properties: {
+            tenantDID: { type: 'string' },
+          },
+          required: ['tenantDID'],
+        },
+        body: {
+          type: 'object',
+          required: ['offer'],
+          properties: {
+            vendorOriginContext: {
+              type: 'string',
+            },
+            offer: {
+              oneOf: [
+                {
+                  $ref: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json#',
+                },
+                {
+                  type: 'array',
+                  items: {
+                    $ref: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json#',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      },
+    },
+    async (req, reply) => {
+      const {
+        body: { offer, vendorOriginContext },
+        params: { tenantDID },
+      } = req;
+      const exchangeId = await createExchange(tenantDID, req);
+      await createCredentialAgentOffers(
+        castArray(offer),
+        tenantDID,
+        exchangeId,
+        req
+      );
+
+      const response = await getExchangeQrCode(
+        tenantDID,
+        exchangeId,
+        vendorOriginContext,
+        req
+      );
+
+      return reply.type('image/png').send(response.rawBody);
+    }
+  );
+};
+
+module.exports = controller;

package/src/controllers/api/issuing-exchanges/fetchers.js

@@ -0,0 +1,45 @@
+const submitCreateExchange = (tenantDID, type, { agentFetch }) =>
+  agentFetch
+    .post(`operator-api/v0.8/tenants/${tenantDID}/exchanges`, {
+      json: { type },
+    })
+    .json();
+
+const getExchangeQrCode = (
+  tenantDID,
+  exchangeId,
+  vendorOriginContext,
+  { agentFetch }
+) => {
+  const urlSearchParams = new URLSearchParams();
+  if (vendorOriginContext != null) {
+    urlSearchParams.set('vendorOriginContext', vendorOriginContext);
+  }
+  return agentFetch.get(
+    `operator-api/v0.8/tenants/${tenantDID}/exchanges/${exchangeId}/qrcode.png?${urlSearchParams.toString()}`
+  );
+};
+
+const submitOffer = ({ offer, tenantDID, exchangeId }, { agentFetch }) =>
+  agentFetch
+    .post(
+      `operator-api/v0.8/tenants/${tenantDID}/exchanges/${exchangeId}/offers`,
+      {
+        json: offer,
+      }
+    )
+    .json();
+
+const completeSubmitOffer = ({ exchangeId, tenantDID }, { agentFetch }) =>
+  agentFetch
+    .post(
+      `operator-api/v0.8/tenants/${tenantDID}/exchanges/${exchangeId}/offers/complete`
+    )
+    .json();
+
+module.exports = {
+  submitOffer,
+  completeSubmitOffer,
+  submitCreateExchange,
+  getExchangeQrCode,
+};

package/src/controllers/api/issuing-exchanges/repo.js

@@ -0,0 +1,27 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+const repo = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'issuingExchanges',
+      entityName: 'issuingExchange',
+      defaultProjection: {
+        _id: 1,
+        type: 1,
+        issuer: 1,
+        exchangeId: 1,
+        vendorUserId: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};
+
+module.exports = repo;

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

@@ -0,0 +1,69 @@
+const { jwtSign, jwtVerify, deriveJwk } = require('@verii/jwt');
+const {
+  jwtRequest,
+  jwtResponse,
+  jwtVerifyRequest,
+  jwtVerifyResponse,
+} = require('./schemas');
+const { getKeyPair } = require('../../../entities');
+
+const controller = async (fastify) => {
+  fastify.post(
+    '/sign',
+    {
+      schema: {
+        tags: ['jose'],
+        body: jwtRequest,
+        response: {
+          200: jwtResponse,
+        },
+      },
+    },
+    async (req) => {
+      const { body } = req;
+      const { header, payload, options } = body;
+
+      const keyPair = getKeyPair(options);
+
+      const compactJwt = await jwtSign(payload, keyPair.privateKey, {
+        ...header,
+        alg: keyPair.alg,
+        jwk: keyPair.publicKey,
+      });
+      return {
+        compactJwt,
+      };
+    }
+  );
+
+  fastify.post(
+    '/verify',
+    {
+      schema: {
+        tags: ['jose'],
+        body: jwtVerifyRequest,
+        response: {
+          200: jwtVerifyResponse,
+        },
+      },
+    },
+    async (req) => {
+      const { body } = req;
+      const { jwt, publicKey } = body;
+      try {
+        const jwk = deriveJwk(jwt, publicKey);
+        await jwtVerify(jwt, jwk);
+        return {
+          verified: true,
+        };
+      } catch (e) {
+        return {
+          verified: false,
+          error: e,
+        };
+      }
+    }
+  );
+};
+
+module.exports = controller;

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

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

package/src/controllers/api/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/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 };

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

@@ -0,0 +1,17 @@
+const jwtVerifyRequest = {
+  title: 'jwt-verify-request',
+  $id: 'https://velocitycareerlabs.io/jwt-verify-request.schema.json',
+  description: 'jwt verify request schema',
+  type: 'object',
+  properties: {
+    jwt: {
+      type: 'string',
+    },
+    publicKey: {
+      type: 'object',
+    },
+  },
+  required: ['jwt'],
+};
+
+module.exports = { jwtVerifyRequest };

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

@@ -0,0 +1,17 @@
+const jwtVerifyResponse = {
+  title: 'jwt-verify-response',
+  $id: 'https://velocitycareerlabs.io/jwt-verify-response.schema.json',
+  description: 'jwt verify response schema',
+  type: 'object',
+  properties: {
+    verified: {
+      type: 'boolean',
+    },
+    error: {
+      type: 'string',
+    },
+  },
+  required: ['verified'],
+};
+
+module.exports = { jwtVerifyResponse };

package/src/controllers/api/offers/autohooks.js

@@ -0,0 +1,5 @@
+const newMockvendorOffer = require('./new-mockvendor-offer.schema');
+
+module.exports = async (fastify) => {
+  fastify.addSchema(newMockvendorOffer);
+};