@verii/server-mockvendor 1.0.0-pre.1752076816

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

@@ -0,0 +1,87 @@
+const { isArray, map } = require('lodash/fp');
+const { nanoid } = require('nanoid');
+
+const prepOffer = (offer) => ({
+  offerId: nanoid(),
+  ...offer,
+});
+
+module.exports = async (fastify) => {
+  fastify.post(
+    '/',
+    {
+      onRequest: fastify.verifyAdmin,
+      schema: {
+        body: {
+          oneOf: [
+            {
+              $ref: 'https://velocitycareerlabs.io/new-mockvendor-offer.schema.json#',
+            },
+            {
+              type: 'array',
+              items: {
+                $ref: 'https://velocitycareerlabs.io/new-mockvendor-offer.schema.json#',
+              },
+            },
+          ],
+        },
+      },
+    },
+    async (req) => {
+      const { body, repos } = req;
+      const offers = isArray(body) ? body : [body];
+      const preppedOffers = map(prepOffer, offers);
+      return repos.offers.insertMany(preppedOffers);
+    }
+  );
+  fastify.put(
+    '/:id',
+    {
+      onRequest: fastify.verifyAdmin,
+    },
+    async (req) => {
+      const {
+        body,
+        params: { id },
+        repos,
+      } = req;
+      return repos.offers.update(id, body);
+    }
+  );
+  fastify.get(
+    '/:id',
+    {
+      onRequest: fastify.verifyAdmin,
+    },
+    async (req) => {
+      const {
+        params: { id },
+        repos,
+      } = req;
+      return repos.offers.findById(id);
+    }
+  );
+  fastify.get(
+    '',
+    {
+      onRequest: fastify.verifyAdmin,
+    },
+    async ({ repos }) => {
+      const offers = await repos.offers.find({});
+      return offers;
+    }
+  );
+  fastify.delete(
+    '/:id',
+    {
+      onRequest: fastify.verifyAdmin,
+    },
+    async (req) => {
+      const {
+        params: { id },
+        repos,
+      } = req;
+      return repos.offers.del(id);
+    }
+  );
+};

package/src/controllers/api/offers/new-mockvendor-offer.schema.js

@@ -0,0 +1,22 @@
+const {
+  newVendorOfferSchema,
+} = require('@verii/server-credentialagent/src/controllers/operator/tenants/_tenantId/offers/schemas');
+const { filter, omit } = require('lodash/fp');
+
+module.exports = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://velocitycareerlabs.io/new-mockvendor-offer.schema.json',
+  title: 'new-mockvendor-offer',
+  description:
+    'An new mockvendor offer, is the same as a regular new-vendor-offer, but with the issuer specified',
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    ...omit(
+      ['offerCreationDate', 'offerExpirationDate'],
+      newVendorOfferSchema.properties
+    ),
+    label: { type: 'string' },
+  },
+  required: [...filter(['offerId'], newVendorOfferSchema.required), 'issuer'],
+};

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

@@ -0,0 +1,33 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+const repo = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'offers',
+      entityName: 'offer',
+      defaultProjection: {
+        _id: 1,
+        '@context': 1,
+        type: 1,
+        issuer: 1,
+        credentialSubject: 1,
+        linkedCredentials: 1,
+        offerId: 1,
+        exchangeId: 1,
+        replaces: 1,
+        relatedResource: 1,
+        label: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};
+
+module.exports = repo;

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

@@ -0,0 +1,20 @@
+const { map, toLower } = require('lodash/fp');
+
+const userController = async (fastify) => {
+  fastify.post('/', async ({ body, repos }) =>
+    repos.users.insert({ ...body, emails: map(toLower, body.emails) })
+  );
+  fastify.get('/', async ({ repos }) => repos.users.find({}));
+  fastify.get('/:id', async ({ params: { id }, repos }) =>
+    repos.users.findById(id)
+  );
+  fastify.delete('/:id', async ({ params: { id }, repos }) =>
+    repos.users.del(id)
+  );
+
+  fastify.put('/:id', async ({ body, params: { id }, repos }) =>
+    repos.users.update(id, body)
+  );
+};
+
+module.exports = userController;

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

@@ -0,0 +1,29 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+module.exports = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'users',
+      entityName: 'user',
+      defaultProjection: {
+        _id: 1,
+        firstName: 1,
+        lastName: 1,
+        emails: 1,
+        phones: 1,
+        address: 1,
+        identityCredentials: 1,
+        label: 1,
+        token: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};

package/src/controllers/autohooks.js

@@ -0,0 +1,22 @@
+const {
+  didServiceSchema,
+  modifyDidServiceSchema,
+  registrarMessage,
+  registrarMessageResponse,
+  newOfferRelatedResourceSchema,
+} = require('@verii/common-schemas');
+const {
+  newVendorOfferSchema,
+} = require('@verii/server-credentialagent/src/controllers/operator/tenants/_tenantId/offers/schemas');
+const { issuerDataSchema } = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(issuerDataSchema)
+    .addSchema(newOfferRelatedResourceSchema)
+    .addSchema(newVendorOfferSchema)
+    .addSchema(modifyDidServiceSchema)
+    .addSchema(didServiceSchema)
+    .addSchema(registrarMessage)
+    .addSchema(registrarMessageResponse);
+};

package/src/controllers/inspection/controller.js

@@ -0,0 +1,39 @@
+const { map, omit } = require('lodash/fp');
+
+const prepCreds = (body) => {
+  const metadata = omit(['credentials'], body);
+  return map((c) => ({ ...c, ...metadata }), body.credentials);
+};
+
+module.exports = async (fastify) => {
+  fastify.post('/find-or-create-applicant', async (request) => {
+    const { body, repos } = request;
+    const applicant = await repos.applicants.insert(body);
+    return { vendorApplicantId: applicant._id };
+  });
+
+  fastify.post('/add-credentials-to-applicant', async (request) => {
+    const { body, repos } = request;
+    await repos.applicants.findById(body.vendorApplicantId);
+    const inserted = await repos.credentialSubmissions.insertMany(
+      prepCreds(body)
+    );
+    return { numProcessed: inserted.length };
+  });
+
+  fastify.post('/receive-unchecked-credentials', async (request) => {
+    const { body, repos } = request;
+    const inserted = await repos.credentialSubmissions.insertMany(
+      prepCreds(body)
+    );
+    return { numProcessed: inserted.length };
+  });
+
+  fastify.post('/receive-checked-credentials', async (request) => {
+    const { body, repos } = request;
+    const inserted = await repos.credentialSubmissions.insertMany(
+      prepCreds(body)
+    );
+    return { numProcessed: inserted.length };
+  });
+};

package/src/controllers/issuing/controller.js

@@ -0,0 +1,158 @@
+const {
+  first,
+  isEmpty,
+  toLower,
+  map,
+  omitBy,
+  omit,
+  isNil,
+} = require('lodash/fp');
+const { wait } = require('@verii/common-functions');
+const newError = require('http-errors');
+const { generateOffersSchema } = require('../../entities');
+
+module.exports = async (fastify) => {
+  fastify.addSchema(generateOffersSchema(fastify));
+
+  fastify.post('/identify', async (req) => {
+    const { body: identification, repos } = req;
+    await repos.identifications.insert({ identification });
+    const { emails, vendorOriginContext: token } = identification;
+    const user = await repos.users.findOne({
+      filter: buildUsersFilter({ emails, token }),
+    });
+    if (!user) {
+      throw new newError.NotFound();
+    }
+    const vendorUserId = first(user.emails);
+    return { vendorUserId };
+  });
+
+  fastify.post(
+    '/generate-offers',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            types: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+            },
+            vendorUserId: {
+              type: 'string',
+            },
+            vendorOrganizationId: {
+              type: 'string',
+            },
+            tenantDID: {
+              type: 'string',
+            },
+            exchangeId: {
+              type: 'string',
+            },
+          },
+          anyOf: [
+            { required: ['vendorOrganizationId'] },
+            { required: ['tenantDID'] },
+          ],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              offers: {
+                type: 'array',
+                items: {
+                  $ref: 'https://velocitycareerlabs.io/generate-offers.schema.json#',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    async ({ body, repos, config }, reply) => {
+      const { omitOfferId, noOffers200, generateOffersDelaySec } = config;
+
+      await wait(generateOffersDelaySec);
+
+      const offers = await repos.offers.find(
+        { filter: buildOffersFilter(body) },
+        omitBy(isNil, {
+          _id: 0,
+          label: 0,
+          createdAt: 0,
+          updatedAt: 0,
+          offerId: omitOfferId ? 0 : null,
+        })
+      );
+      if (!isEmpty(offers) || noOffers200) {
+        return { offers };
+      }
+
+      await repos.issuingExchanges.insert({
+        type: body.types,
+        ...omit(['types'], body),
+      });
+
+      return reply.status(202).send({});
+    }
+  );
+
+  fastify.post('/receive-issued-credentials', async (req) => {
+    const { body, repos } = req;
+    return repos.acceptedOffers.insert(body);
+  });
+};
+
+const buildIssuerFilter = ({ tenantDID, vendorOrganizationId }) => {
+  if (!isEmpty(tenantDID) && !isEmpty(vendorOrganizationId)) {
+    return {
+      $or: [
+        { 'issuer.id': tenantDID },
+        { 'issuer.vendorOrganizationId': vendorOrganizationId },
+      ],
+    };
+  }
+  if (!isEmpty(tenantDID)) {
+    return { 'issuer.id': tenantDID };
+  }
+  if (!isEmpty(vendorOrganizationId)) {
+    return { 'issuer.vendorOrganizationId': vendorOrganizationId };
+  }
+  return {};
+};
+const buildTypesFilter = ({ types }) => {
+  if (!isEmpty(types)) {
+    return { type: { $elemMatch: { $in: types } } };
+  }
+
+  return {};
+};
+
+const buildUsersFilter = ({ emails, token }) => {
+  const $or = [];
+  if (!isEmpty(emails)) {
+    $or.push({
+      emails: { $in: map(toLower, emails) },
+    });
+  }
+  if (!isEmpty(token)) {
+    $or.push({
+      token,
+    });
+  }
+  return {
+    $or,
+  };
+};
+
+const buildOffersFilter = ({ vendorUserId, ...props }) => ({
+  'credentialSubject.vendorUserId': vendorUserId,
+  exchangeId: { $exists: false },
+  ...buildIssuerFilter(props),
+  ...buildTypesFilter(props),
+});

package/src/controllers/registrar/controller.js

@@ -0,0 +1,67 @@
+const { wait } = require('@verii/common-functions');
+const { verifyVnfSignature } = require('@verii/crypto');
+const { VNF_SIGNATURE_HTTP_HEADER_NAME } = require('@verii/crypto');
+
+module.exports = async (fastify) => {
+  fastify.post(
+    '/registrar-webhook',
+    {
+      schema: {
+        body: { $ref: 'registrar-message#' },
+        response: {
+          200: { $ref: 'registrar-message-response#' },
+        },
+      },
+    },
+    async (req) => {
+      await processingRequest(req);
+      return { messageType: 'ack', messageId: req.body.messageId };
+    }
+  );
+  fastify.post(
+    '/registrar-webhook-delay',
+    {
+      schema: {
+        body: { $ref: 'registrar-message#' },
+        response: {
+          200: { $ref: 'registrar-message-response#' },
+        },
+      },
+    },
+    async (req) => {
+      await wait(30000);
+      await processingRequest(req);
+      return { messageType: 'ack', messageId: req.body.messageId };
+    }
+  );
+  fastify.post(
+    '/registrar-webhook-bad-protocol',
+    {
+      schema: {
+        body: { $ref: 'registrar-message#' },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              foo: { type: 'string' },
+            },
+          },
+        },
+      },
+    },
+    async (req) => {
+      await processingRequest(req);
+      return { foo: 'foo' };
+    }
+  );
+};
+
+const processingRequest = async (req) => {
+  const { repos } = req;
+  const vnfSignatureVerified = verifyVnfSignature(
+    req.body,
+    req.headers[VNF_SIGNATURE_HTTP_HEADER_NAME],
+    req
+  );
+  await repos.messages.insert({ ...req.body, vnfSignatureVerified });
+};

package/src/controllers/registrar/repo.js

@@ -0,0 +1,24 @@
+const {
+  autoboxIdsExtension,
+  repoFactory,
+} = require('@spencejs/spence-mongo-repos');
+
+module.exports = (app, opts, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'messages',
+      entityName: 'message',
+      defaultProjection: {
+        _id: 1,
+        messageType: 1,
+        messageId: 1,
+        payload: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+      extensions: [autoboxIdsExtension],
+    },
+    app
+  );
+};

package/src/controllers/root/controller.js

@@ -0,0 +1,15 @@
+const rootRoutes = async (fastify) => {
+  fastify.get('/', async (req, reply) => {
+    reply
+      .status(200)
+      .send(`Welcome to Mockvendor\nVersion: ${fastify.config.version}\n`);
+  });
+  fastify.post('/test-integration', async (req, reply) => {
+    return reply.status(200).send({ messageReceived: req.body.message });
+  });
+};
+
+// eslint-disable-next-line better-mutation/no-mutation
+rootRoutes.prefixOverride = '';
+
+module.exports = rootRoutes;

package/src/controllers/schemas/index.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const issuerDataSchema = require('./issuer-data.schema.json');
+
+module.exports = {
+  issuerDataSchema,
+};

package/src/controllers/schemas/issuer-data.schema.json

@@ -0,0 +1,26 @@
+{
+  "title": "issuer-data",
+  "type": "object",
+  "$id": "https://velocitynetwork.foundation/schemas/issuer-data.schema.json",
+  "description": "issuer data schema",
+  "properties": {
+    "credentialType": {
+      "type": "string"
+    },
+    "issuer": {
+      "type": "string"
+    },
+    "issued": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "validFrom": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "validUntil": {
+      "type": "string",
+      "format": "date-time"
+    }
+  }
+}

package/src/entities/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('./key-pairs'),
+  ...require('./offers'),
+};

package/src/entities/key-pairs/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./key-pairs'),
+};

package/src/entities/key-pairs/key-pairs.js

@@ -0,0 +1,73 @@
+const { flow, filter, first, isEmpty, pick, values } = require('lodash/fp');
+const newError = require('http-errors');
+
+const keyPairs = {
+  secp256k1: {
+    id: '9dqEq7bVkmjiw5Wi5oxim',
+    // eslint-disable-next-line max-len
+    did: 'did:jwk:eyJjcnYiOiJzZWNwMjU2azEiLCJrdHkiOiJFQyIsIngiOiJBWkpreFVRZlNwS3VvNjVaMWlSeWJZallaRUZOQ2N4VzA2TURCOEpjSHdBIiwieSI6Im5uQk5yZ09OeEFkbGFwZ2RSWlpzT1FxQkNZREFieWtnQ2R2b1ZiNWxtVVkifQ',
+    // eslint-disable-next-line max-len
+    kid: 'did:jwk:eyJjcnYiOiJzZWNwMjU2azEiLCJrdHkiOiJFQyIsIngiOiJBWkpreFVRZlNwS3VvNjVaMWlSeWJZallaRUZOQ2N4VzA2TURCOEpjSHdBIiwieSI6Im5uQk5yZ09OeEFkbGFwZ2RSWlpzT1FxQkNZREFieWtnQ2R2b1ZiNWxtVVkifQ#0',
+    alg: 'ES256K',
+    publicKey: {
+      kty: 'EC',
+      x: 'AZJkxUQfSpKuo65Z1iRybYjYZEFNCcxW06MDB8JcHwA',
+      y: 'nnBNrgONxAdlapgdRZZsOQqBCYDAbykgCdvoVb5lmUY',
+      crv: 'secp256k1',
+    },
+    privateKey: {
+      kty: 'EC',
+      x: 'AZJkxUQfSpKuo65Z1iRybYjYZEFNCcxW06MDB8JcHwA',
+      y: 'nnBNrgONxAdlapgdRZZsOQqBCYDAbykgCdvoVb5lmUY',
+      crv: 'secp256k1',
+      d: 'Sn1OGP_FWYqv0EpfjIY-hL9XMp1JI6X3l-M8ovtz3ng',
+    },
+  },
+  'P-256': {
+    id: 'Iv5pwCQfp6e5FsncVgVX0',
+    // eslint-disable-next-line max-len
+    did: 'did:jwk:eyJjcnYiOiJQLTI1NiIsImt0eSI6IkVDIiwieCI6IkFYQWxaWThqNGh5cm10dzBoRjNrLTJWT080THZXRzBLNEF5a0JYS25HVWciLCJ5IjoiYzlEVHE5cVRWUTlRQmlsLUgxdGRWN3FZZERic3BhTG5wZ0FJdkRKeEpHayJ9',
+    // eslint-disable-next-line max-len
+    kid: 'did:jwk:eyJjcnYiOiJQLTI1NiIsImt0eSI6IkVDIiwieCI6IkFYQWxaWThqNGh5cm10dzBoRjNrLTJWT080THZXRzBLNEF5a0JYS25HVWciLCJ5IjoiYzlEVHE5cVRWUTlRQmlsLUgxdGRWN3FZZERic3BhTG5wZ0FJdkRKeEpHayJ9#0',
+    alg: 'ES256',
+    publicKey: {
+      kty: 'EC',
+      x: 'AXAlZY8j4hyrmtw0hF3k-2VOO4LvWG0K4AykBXKnGUg',
+      y: 'c9DTq9qTVQ9QBil-H1tdV7qYdDbspaLnpgAIvDJxJGk',
+      crv: 'P-256',
+    },
+    privateKey: {
+      kty: 'EC',
+      x: 'AXAlZY8j4hyrmtw0hF3k-2VOO4LvWG0K4AykBXKnGUg',
+      y: 'c9DTq9qTVQ9QBil-H1tdV7qYdDbspaLnpgAIvDJxJGk',
+      crv: 'P-256',
+      d: 'fcZ8We_GOQKA_hC4ovf4UcBnwfcTVkHGwxhN3WDzD7M',
+    },
+  },
+};
+
+const getKeyPair = ({ kid, keyId }) => {
+  let matcher;
+
+  if (!isEmpty(kid)) {
+    matcher = { kid };
+  } else if (!isEmpty(keyId)) {
+    matcher = { id: keyId };
+  }
+
+  const keyPairEntry = flow(filter(matcher), first)(values(keyPairs));
+
+  if (isEmpty(keyPairEntry)) {
+    throw newError(400, 'Key pair not found', {
+      errorCode: `invalid_${!isEmpty(kid) ? 'kid' : 'key_id'}`,
+    });
+  }
+
+  return pick(['publicKey', 'privateKey', 'alg'], keyPairEntry);
+};
+
+const generateJwk = (curve) => {
+  return keyPairs[curve];
+};
+
+module.exports = { generateJwk, getKeyPair };

package/src/entities/offers/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./schemas'),
+};

package/src/entities/offers/schemas/generate-offers.schema.js

@@ -0,0 +1,30 @@
+const {
+  newVendorOfferSchema,
+} = require('@verii/server-credentialagent/src/controllers/operator/tenants/_tenantId/offers/schemas');
+const { filter, omit } = require('lodash/fp');
+
+module.exports = (context) => ({
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://velocitycareerlabs.io/generate-offers.schema.json',
+  title: 'generate-offers',
+  description:
+    'A generate offers, is the same as a regular new-vendor-offer, but without required param offer id',
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    ...omit(
+      ['offerCreationDate', 'offerExpirationDate'],
+      newVendorOfferSchema.properties
+    ),
+  },
+  required: [
+    ...filter(
+      [
+        'type',
+        'credentialSubject',
+        ...(context.config.omitOfferId ? [] : ['offerId']),
+      ],
+      newVendorOfferSchema.required
+    ),
+  ],
+});