@verii/server-credentialagent 1.0.0-pre.1752076816

package/src/controllers/operator/tenants/_tenantId/offers/autohooks.js

@@ -0,0 +1,34 @@
+/**
+ * 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 { exchangeLoaderPlugin } = require('../../../../../plugins');
+const { vendorOfferSchema } = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .register(exchangeLoaderPlugin)
+    .addSchema(vendorOfferSchema)
+    .autoSchemaPreset({
+      params: {
+        type: 'object',
+        properties: {
+          ...fastify.currentAutoSchemaPreset.params.properties,
+          exchangeId: { type: 'string', minLength: 1 },
+        },
+      },
+      tags: ['offer-exchanges'],
+    });
+};

package/src/controllers/operator/tenants/_tenantId/offers/controller-v0.8.js

@@ -0,0 +1,253 @@
+/**
+ * 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 { resolveDid } = require('@verii/common-fetchers');
+const newError = require('http-errors');
+const { isEmpty, includes, map, flow, first, uniq } = require('lodash/fp');
+const { nanoid } = require('nanoid/non-secure');
+const qr = require('qr-image');
+
+const {
+  prepareOffers,
+  ExchangeStates,
+  NotificationTypes,
+  postValidationOffersHandler,
+  buildExchangeRequestDeepLink,
+  initValidateOffer,
+} = require('../../../../../entities');
+const { sendPush } = require('../../../../../fetchers');
+const { loadDisclosure } = require('../../../../../plugins');
+
+const canPushNotification = (exchange) =>
+  !!(exchange.pushDelegate && exchange.pushDelegate.pushUrl);
+
+const offerExchangeController = async (fastify) => {
+  const validateOffer = initValidateOffer(fastify);
+
+  fastify.post(
+    '/offers',
+    {
+      preHandler: [
+        postValidationOffersHandler,
+        async (req) => {
+          // eslint-disable-next-line better-mutation/no-mutation
+          req.disclosure = await loadDisclosure(req);
+        },
+      ],
+      schema: fastify.autoSchema({
+        body: {
+          $ref: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json#',
+        },
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/vendor-offer.schema.json#',
+          },
+          ...fastify.UnprocessableEntityResponse,
+        },
+      }),
+      attachValidation: true,
+    },
+    async (req) => {
+      const { body: vendorOffer, repos, exchange } = req;
+
+      const validatedOffer = await validateOffer(
+        vendorOffer,
+        false,
+        false,
+        req
+      );
+
+      const preparedOffers = await prepareOffers([validatedOffer], req);
+
+      const offer = first(preparedOffers);
+      if (includes(offer.contentHash.value, exchange.offerHashes)) {
+        throw newError.UnprocessableEntity(
+          'Wallet already contains this offer'
+        );
+      }
+      return repos.offers.insert(offer);
+    }
+  );
+
+  fastify.post(
+    '/offers/complete',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              offerIds: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              pushSentAt: {
+                type: 'string',
+                format: 'date-time',
+              },
+            },
+            description: 'Offers transmission complete',
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos, exchange, tenant } = req;
+
+      const orgDoc = await resolveDid(tenant.did, req);
+      if (isEmpty(orgDoc)) {
+        throw new newError.NotFound(
+          `No organization found for issuer ${tenant.did}`
+        );
+      }
+
+      const offers = await repos.offers.find(
+        { filter: { exchangeId: exchange._id } },
+        { _id: 1, issuer: 1, offerId: 1, type: 1 }
+      );
+
+      if (isEmpty(offers)) {
+        if (!canPushNotification(exchange)) {
+          await repos.exchanges.addState(
+            exchange._id,
+            ExchangeStates.NO_OFFERS_RECEIVED
+          );
+          await repos.exchanges.addState(exchange._id, ExchangeStates.COMPLETE);
+          return {};
+        }
+        await sendPush(
+          {
+            id: nanoid(),
+            pushToken: exchange.pushDelegate.pushToken,
+            data: {
+              notificationType: NotificationTypes.NO_OFFERS_FOUND,
+              issuer: tenant.did,
+              exchangeId: exchange._id,
+              serviceEndpoint: exchange.pushDelegate.pushUrl,
+            },
+          },
+          req.exchange.pushDelegate,
+          req
+        );
+        const pushSentAt = new Date();
+        await repos.exchanges.addState(
+          exchange._id,
+          ExchangeStates.NO_OFFERS_RECEIVED,
+          { pushSentAt }
+        );
+        await repos.exchanges.addState(exchange._id, ExchangeStates.COMPLETE);
+        return {
+          pushSentAt,
+        };
+      }
+
+      await repos.exchanges.addState(
+        exchange._id,
+        ExchangeStates.OFFERS_RECEIVED
+      );
+
+      const offerIds = map('_id', offers);
+      if (!canPushNotification(exchange)) {
+        return { offerIds };
+      }
+
+      const types = flow(map('type.0'), uniq)(offers);
+      await sendPush(
+        {
+          id: nanoid(),
+          pushToken: exchange.pushDelegate.pushToken,
+          data: {
+            notificationType: NotificationTypes.NEW_OFFER_READY,
+            issuer: tenant.did,
+            exchangeId: exchange._id,
+            serviceEndpoint: exchange.pushDelegate.pushUrl,
+            credentialTypes: types,
+            count: offers.length,
+          },
+        },
+        req.exchange.pushDelegate,
+        req
+      );
+      const pushSentAt = new Date();
+      await repos.exchanges.update(exchange._id, { pushSentAt });
+      return {
+        offerIds,
+        pushSentAt,
+      };
+    }
+  );
+
+  fastify
+    .get(
+      '/qrcode.uri',
+      {
+        schema: fastify.autoSchema({
+          querystring: {
+            type: 'object',
+            properties: {
+              vendorOriginContext: { type: 'string' },
+            },
+          },
+          response: {
+            200: {
+              description: 'qr code deep link',
+              content: {
+                'text/plain': { schema: { type: 'string', format: 'uri' } },
+              },
+            },
+          },
+        }),
+      },
+      async (req, reply) => {
+        const uri = await buildExchangeRequestDeepLink(req);
+        return reply.type('text/plain').send(uri);
+      }
+    )
+    .get(
+      '/qrcode.png',
+      {
+        schema: fastify.autoSchema({
+          querystring: {
+            type: 'object',
+            properties: {
+              vendorOriginContext: { type: 'string' },
+            },
+          },
+          response: {
+            200: {
+              description: 'qr code image response',
+              content: {
+                'image/png': { schema: { type: 'string', format: 'binary' } },
+              },
+            },
+          },
+        }),
+      },
+      async (req, reply) => {
+        const uri = await buildExchangeRequestDeepLink(req);
+        const qrCodeBuffer = qr.imageSync(uri, {
+          ec_level: 'H',
+          type: 'png',
+        });
+
+        return reply.type('image/png').send(qrCodeBuffer);
+      }
+    );
+};
+
+module.exports = offerExchangeController;
+
+module.exports.autoPrefix = '/tenants/:tenantId/exchanges/:exchangeId';

package/src/controllers/operator/tenants/_tenantId/offers/schemas/index.js

@@ -0,0 +1,23 @@
+/**
+ * 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 newVendorOfferSchema = require('./new-vendor-offer.schema');
+const vendorOfferSchema = require('./vendor-offer.schema.json');
+
+module.exports = {
+  newVendorOfferSchema,
+  vendorOfferSchema,
+};

package/src/controllers/operator/tenants/_tenantId/offers/schemas/new-vendor-offer.schema.js

@@ -0,0 +1,47 @@
+const { w3cVcSchema } = require('@verii/common-schemas');
+
+const newVendorOfferSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://velocitycareerlabs.io/new-vendor-offer.schema.json',
+  type: 'object',
+  title: 'new-vendor-offer',
+  description:
+    'An offer is similar to a credential but is never wrapped in a JWT and hence doesnt carry the JWS (digital signature)',
+  additionalProperties: false,
+  properties: {
+    ...w3cVcSchema.properties,
+    credentialSubject: {
+      type: 'object',
+      description: 'Contains all the claims of the credential',
+      additionalProperties: true,
+      required: ['vendorUserId'],
+      properties: {
+        vendorUserId: {
+          type: 'string',
+          description:
+            // eslint-disable-next-line max-len
+            "The vendor's id for the person. This is only used to communicate to the vendor's api and is never shared with external parties or the velocity network.",
+        },
+      },
+    },
+    offerCreationDate: {
+      type: 'string',
+      format: 'date-time',
+      deprecated: true,
+    },
+    offerExpirationDate: {
+      type: 'string',
+      format: 'date-time',
+      deprecated: true,
+    },
+    offerId: {
+      type: 'string',
+    },
+    exchangeId: {
+      type: 'string',
+    },
+  },
+  required: ['offerId', ...w3cVcSchema.required],
+};
+
+module.exports = newVendorOfferSchema;

package/src/controllers/operator/tenants/_tenantId/offers/schemas/vendor-offer.schema.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://velocitycareerlabs.io/vendor-offer.schema.json",
+  "type": "object",
+  "title": "vendor-offer",
+  "description": "An offer is similar to a credential but is never wrapped in a JWT and hence doesnt carry the JWS (digital signature)",
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "$ref": "https://velocitycareerlabs.io/new-vendor-offer.schema.json#"
+    },
+    {
+      "$ref": "mutable-entity#"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "issuer": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              ]
+            },
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string",
+              "description": "The name of brand"
+            },
+            "image": {
+              "type": "string",
+              "description": "The uri to image"
+            }
+          },
+          "additionalProperties": true
+        }
+      },
+      "required": [
+        "type",
+        "credentialSubject",
+        "exchangeId"
+      ]
+    }
+  ]
+}

package/src/controllers/operator/tenants/_tenantId/users/autohooks.js

@@ -0,0 +1,24 @@
+/**
+ * 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 { newUserSchema, userSchema } = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(newUserSchema)
+    .addSchema(userSchema)
+    .autoSchemaPreset({ tags: ['users'] });
+};

package/src/controllers/operator/tenants/_tenantId/users/controller-v0.8.js

@@ -0,0 +1,92 @@
+/**
+ * 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 { omit } = require('lodash/fp');
+
+const vendorUserIdMappingController = async (fastify) => {
+  const specificParams = {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      ...fastify.currentAutoSchemaPreset.params.properties,
+    },
+  };
+
+  fastify.post(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        body: { $ref: 'https://velocitycareerlabs.io/new-user.schema.json#' },
+        response: {
+          201: { $ref: 'https://velocitycareerlabs.io/user.schema.json#' },
+        },
+      }),
+    },
+    async ({ body, repos }) =>
+      repos.vendorUserIdMappings.upsert(
+        body.id || body.email,
+        omit(['id'], body)
+      )
+  );
+
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'array',
+            items: {
+              $ref: 'https://velocitycareerlabs.io/user.schema.json#',
+            },
+          },
+        },
+      }),
+    },
+    async ({ repos }) => repos.vendorUserIdMappings.find({})
+  );
+
+  fastify.get(
+    '/:id',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        response: {
+          200: { $ref: 'https://velocitycareerlabs.io/user.schema.json#' },
+        },
+      }),
+    },
+    async ({ params: { id }, repos }) => repos.vendorUserIdMappings.findById(id)
+  );
+
+  fastify.delete(
+    '/:id',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        response: {
+          204: { type: 'null', description: 'No Content' },
+        },
+      }),
+    },
+    async ({ params: { id }, repos }, reply) => {
+      reply.status(204);
+      return repos.vendorUserIdMappings.del(id);
+    }
+  );
+};
+
+module.exports = vendorUserIdMappingController;

package/src/controllers/operator/tenants/_tenantId/users/schemas/index.js

@@ -0,0 +1,23 @@
+/**
+ * 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 userSchema = require('./user.schema.json');
+const newUserSchema = require('./new-user.schema.json');
+
+module.exports = {
+  newUserSchema,
+  userSchema,
+};

package/src/controllers/operator/tenants/_tenantId/users/schemas/new-user.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://velocitycareerlabs.io/new-user.schema.json",
+  "title": "new-user",
+  "description": "an agent holder user",
+  "type": "object",
+  "properties": {
+    "vendorUserId": {
+      "type": "string"
+    }
+  },
+  "required": ["vendorUserId"]
+}

package/src/controllers/operator/tenants/_tenantId/users/schemas/user.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://velocitycareerlabs.io/user.schema.json",
+  "title": "user",
+  "description": "The user",
+  "allOf": [
+    { "$ref": "https://velocitycareerlabs.io/new-user.schema.json#"},
+    { "$ref": "mutable-entity#"}
+  ],
+  "required": [
+    "id",
+    "vendorUserId",
+    "createdAt",
+    "updatedAt"
+  ]
+}

package/src/controllers/operator/tenants/_tenantId/vc-api/credentials/autohooks.js

@@ -0,0 +1,34 @@
+/**
+ * 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 {
+  CredentialSchema,
+  IssueCredentialOptionsSchema,
+  IssueCredentialRequestSchema,
+  IssueCredentialResponseSchema,
+  LinkedDataProofSchema,
+  VerifiableCredentialSchema,
+} = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(CredentialSchema)
+    .addSchema(LinkedDataProofSchema)
+    .addSchema(VerifiableCredentialSchema)
+    .addSchema(IssueCredentialOptionsSchema)
+    .addSchema(IssueCredentialRequestSchema)
+    .addSchema(IssueCredentialResponseSchema)
+    .autoSchemaPreset({ tags: ['vc-api-issuing'] });
+};