@verii/server-credentialagent 1.0.0-pre.1752076816

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

@@ -0,0 +1,73 @@
+/**
+ * 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 { getExchangeResponseBodySchema } = require('../schemas');
+const {
+  buildExchangeRequestDeepLink,
+  velocityProtocolUriToHttpUri,
+} = require('../../../../../../entities');
+
+const exchangeController = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: getExchangeResponseBodySchema,
+        },
+      }),
+    },
+    async (req) => {
+      const { exchange } = req;
+      return {
+        exchange: {
+          ...exchange,
+          id: exchange._id,
+        },
+      };
+    }
+  );
+  fastify.get(
+    '/deep-link',
+    {
+      schema: fastify.autoSchema({
+        querystring: {
+          type: 'object',
+          properties: {
+            vendorOriginContext: { type: 'string' },
+          },
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: { deepLink: { type: 'string' } },
+            required: ['deepLink'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const exchangeDeepLink = await buildExchangeRequestDeepLink(req);
+      const httpProtocolDeepLink = velocityProtocolUriToHttpUri(
+        exchangeDeepLink,
+        req
+      );
+      return { deepLink: httpProtocolDeepLink };
+    }
+  );
+};
+
+module.exports = exchangeController;

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+
+module.exports = async (fastify) => {
+  fastify.autoSchemaPreset({ tags: ['offer-exchanges'] });
+};

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

@@ -0,0 +1,150 @@
+/**
+ * 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 Ajv = require('ajv');
+const { isEmpty, flow, map, concat, uniq } = require('lodash/fp');
+const newError = require('http-errors');
+const {
+  ExchangeTypes,
+  VendorEndpoint,
+  ExchangeErrors,
+} = require('../../../../../entities');
+
+const exchangeController = async (fastify) => {
+  const ajvNoCoerce = new Ajv({
+    ...fastify.config.ajvOptions,
+    coerceTypes: false,
+  });
+  fastify.post(
+    '/',
+    {
+      validatorCompiler: ({ schema }) => ajvNoCoerce.compile(schema),
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['ISSUING', 'DISCLOSURE'] },
+            disclosureId: { type: 'string' },
+            identityMatcherValues: {
+              type: 'array',
+              items: {
+                anyOf: [
+                  {
+                    type: 'string',
+                  },
+                  {
+                    type: 'number',
+                  },
+                  {
+                    type: 'boolean',
+                  },
+                ],
+              },
+            },
+          },
+          required: ['type'],
+        },
+        response: {
+          201: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            additionalProperties: false,
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const { repos, body, user } = req;
+      const disclosure = await resolveDisclosure(body, req);
+      const exchange = {
+        disclosureId: disclosure._id,
+        type: body.type,
+        identityMatcherValues: body.identityMatcherValues,
+        createdBy: user.user,
+      };
+
+      validateExchange(exchange, disclosure);
+
+      const { _id } = await repos.exchanges.insertWithInitialState(exchange);
+      reply.code(201);
+      return { id: _id };
+    }
+  );
+
+  const validateExchange = (exchange, disclosure) => {
+    if (
+      disclosure.vendorEndpoint !==
+      VendorEndpoint.INTEGRATED_ISSUING_IDENTIFICATION
+    ) {
+      return;
+    }
+
+    if (isEmpty(exchange.identityMatcherValues)) {
+      throw newError.BadRequest(
+        ExchangeErrors.IDENTITY_MATCHER_VALUES_REQUIRED
+      );
+    }
+
+    const indexes = buildValueIndexes(disclosure.identityMatchers);
+    validateRowDefinesAllIndexes(exchange.identityMatcherValues, indexes);
+  };
+
+  const buildValueIndexes = ({ rules, vendorUserIdIndex }) =>
+    flow(map('valueIndex'), concat([vendorUserIdIndex]), uniq)(rules);
+
+  const validateRowDefinesAllIndexes = (row, indexes) => {
+    for (const index of indexes) {
+      if (
+        row[index] == null ||
+        (typeof row[index] === 'string' && isEmpty(row[index]))
+      ) {
+        throw newError.BadRequest(
+          ExchangeErrors.IDENTITY_MATCHER_VALUE_REQUIRED(index)
+        );
+      }
+    }
+  };
+
+  const resolveDisclosure = async (
+    { type, disclosureId },
+    { repos, tenant }
+  ) => {
+    if (!isEmpty(disclosureId)) {
+      return repos.disclosures.findById(disclosureId);
+    }
+    if (type === ExchangeTypes.DISCLOSURE) {
+      throw new newError.BadRequest(ExchangeErrors.DISCLOSURE_ID_REQUIRED);
+    }
+
+    const disclosure = await repos.disclosures.findOne(
+      {
+        filter: {
+          vendorEndpoint: VendorEndpoint.ISSUING_IDENTIFICATION,
+        },
+      },
+      { _id: 1 }
+    );
+
+    if (isEmpty(disclosure)) {
+      throw new newError.BadRequest(
+        ExchangeErrors.IDENTIFICATION_DISCLOSURE_MISSING_TEMPLATE(tenant)
+      );
+    }
+    return disclosure;
+  };
+};
+
+module.exports = exchangeController;

package/src/controllers/operator/tenants/_tenantId/exchanges/schemas/get-exchange.response.body.json

@@ -0,0 +1,147 @@
+{
+  "$id": "https://velocitycareerlabs.io/agent-operator-get-exchange-response-body",
+  "title": "agent-operator-get-exchange-response-body",
+  "type": "object",
+  "properties": {
+    "exchange": {
+      "type": "object",
+      "required": [
+        "id",
+        "type",
+        "disclosureId",
+        "events",
+        "createdAt",
+        "updatedAt"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "the exchange id"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "ISSUING",
+            "DISCLOSURE"
+          ],
+          "description": "the type of exchange"
+        },
+        "disclosureId": {
+          "type": "string",
+          "description": "the disclosure associated to the exchange"
+        },
+        "disclosureConsentedAt": {
+          "type": "string",
+          "format": "date-time",
+          "description": "when the holder consented to the disclosure"
+        },
+        "disclosureRejectedAt": {
+          "type": "string",
+          "format": "date-time",
+          "description": "disclosure was rejected by the holder and will not proceed with the exchange"
+        },
+        "presentationId": {
+          "type": "string",
+          "description": "presentationId received for the disclosure request"
+        },
+        "pushDelegate": {
+          "type": "object",
+          "description": "push metadata",
+          "properties": {
+            "pushUrl": {
+              "type": "string"
+            },
+            "pushToken": {
+              "type": "string"
+            }
+          }
+        },
+        "pushSentAt": {
+          "type": "string",
+          "format": "date-time",
+          "description": "when was the push sent at?"
+        },
+        "protocolMetadata": {
+          "type": "object",
+          "patternProperties": {
+            ".*": {
+              "type": "string"
+            }
+          }
+        },
+        "identityMatcherValues": {
+          "type": "array",
+          "description": "identity matcher value used by agent when generating offers from a offer template held on the disclosure",
+          "items": {
+            "anyOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "string"
+              },
+              {
+                "type": "boolean"
+              }
+            ]
+          }
+        },
+        "events": {
+          "type": "array",
+          "description": "The events array. the last entry is the current state of the exchange. ",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "state": {
+                "type": "string",
+                "description": "state that the exchange entered at that timestamp"
+              },
+              "timestamp": {
+                "type": "string",
+                "format": "date-time",
+                "description": "timestamp of the event"
+              }
+            },
+            "required": [
+              "state",
+              "timestamp"
+            ]
+          }
+        },
+        "vendorUserId": {
+          "type": "string"
+        },
+        "vendorOfferStatuses": {
+          "type": "object",
+          "patternProperties": {
+            ".*": {
+              "type": "string"
+            }
+          }
+        },
+        "offerIds": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "err": {
+          "type": "string",
+          "description": "message about the error received. If err is set, then the exchange is in a failure state and probably cannot be recovered"
+        },
+        "createdAt": {
+          "type": "string",
+          "description": "when the exchange was created"
+        },
+        "updatedAt": {
+          "type": "string",
+          "description": "when the exchange was last updated"
+        }
+      }
+    }
+  },
+  "required": [
+    "exchange"
+  ]
+}

package/src/controllers/operator/tenants/_tenantId/exchanges/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 getExchangeResponseBodySchema = require('./get-exchange.response.body.json');
+
+module.exports = {
+  getExchangeResponseBodySchema,
+};

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

@@ -0,0 +1,27 @@
+/**
+ * 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 { revokeCredentialSchema, issuedCredentialSchema } = require('./schemas');
+const { ensureTenantPrimaryAddressPlugin } = require('../../../../../plugins');
+
+module.exports = async (fastify) =>
+  fastify
+    .register(ensureTenantPrimaryAddressPlugin)
+    .addSchema(issuedCredentialSchema)
+    .addSchema(revokeCredentialSchema)
+    .autoSchemaPreset({
+      tags: ['credentials'],
+    });