@verii/server-credentialing-hub 2.0.0

package/src/controllers/operator/tenants/tenants-controller.js

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2024 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 { coerceArray } = require('@verii/common-functions');
+const {
+  createTenant,
+  deleteTenant,
+  findTenants,
+} = require('../../../entities/tenants');
+const {
+  jwkSchema,
+  newTenantSchema,
+  tenantSchema,
+  newKeyMetadataSchema,
+  keyMetadataSchema,
+  secretKeySchema,
+  newKeySchema,
+} = require('./schemas');
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(jwkSchema)
+    .addSchema(newTenantSchema)
+    .addSchema(tenantSchema)
+    .addSchema(newKeyMetadataSchema)
+    .addSchema(keyMetadataSchema)
+    .addSchema(secretKeySchema)
+    .addSchema(newKeySchema)
+    .post(
+      '/create',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenant: {
+                $ref: 'new-tenant#',
+              },
+              keys: {
+                type: 'array',
+                minItems: 1,
+                items: {
+                  $ref: 'new-key#',
+                },
+              },
+            },
+            required: ['tenant', 'keys'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                tenant: {
+                  $ref: 'tenant#',
+                },
+                keyMetadatas: {
+                  type: 'array',
+                  items: {
+                    $ref: 'key-metadata#',
+                  },
+                },
+                requestId: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const { tenant, keyMetadatas } = await createTenant(
+          req.body.tenant,
+          req.body.keys,
+          req,
+        );
+        return { tenant, keyMetadatas };
+      },
+    )
+    .get(
+      '/get',
+      {
+        schema: fastify.autoSchema({
+          query: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                anyOf: [
+                  { type: 'string' },
+                  {
+                    type: 'array',
+                    items: {
+                      type: 'string',
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                tenants: {
+                  type: 'array',
+                  items: {
+                    $ref: 'tenant#',
+                  },
+                },
+                requestId: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const tenants = await findTenants(
+          coerceArray(req.query?.tenantId),
+          req,
+        );
+        return { tenants };
+      },
+    )
+    .post(
+      '/delete',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+            },
+            required: ['tenantId'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                requestId: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        }),
+      },
+      async (req) => deleteTenant(req.body.tenantId, req),
+    );
+};

package/src/controllers/root-controller.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 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 rootController = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: {
+        description: 'Healthcheck and version info',
+        response: {
+          200: {
+            description: 'Successful response',
+            content: { 'text/plain': { schema: { type: 'string' } } },
+          },
+        },
+        tags: ['utilities'],
+      },
+    },
+    async (req, reply) => {
+      reply
+        .status(200)
+        .send(
+          `Welcome to the Credentialing Hub\nHost: ${fastify.config.hostUrl}\nVersion: ${fastify.config.version}\n`,
+        );
+    },
+  );
+};
+
+module.exports = rootController;

package/src/controllers/vn-api/schemas/index.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2024 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 presentationSubmissionSchema = require('./presentation-submission.schema.json');
+const velocityPresentationSubmissionSchema = require('./velocity-presentation-submission.schema.json');
+const velocityPresentationSubmissionResponseSchema = require('./velocity-presentation-submission.response.200.schema.json');
+
+module.exports = {
+  presentationSubmissionSchema,
+  velocityPresentationSubmissionSchema,
+  velocityPresentationSubmissionResponseSchema,
+};

package/src/controllers/vn-api/schemas/presentation-submission.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Presentation Submission",
+  "$id": "https://velocitycareerlabs.io/presentation-submission.schema.json",
+  "type": "object",
+  "properties": {
+    "presentation_submission": {
+      "type": "object",
+      "properties": {
+        "id": { "type": "string" },
+        "definition_id": { "type": "string" },
+        "locale": { "type": "string" },
+        "descriptor_map": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/descriptor" }
+        }
+      },
+      "required": ["descriptor_map", "definition_id"],
+      "additionalProperties": false
+    }
+  },
+  "definitions": {
+    "descriptor": {
+      "type": "object",
+      "properties": {
+        "id": { "type": "string" },
+        "path": { "type": "string" },
+        "path_nested": {
+          "$ref": "#/definitions/descriptor"
+        },
+        "format": {
+          "type": "string",
+          "enum": ["jwt", "jwt_vc", "jwt_vp", "ldp", "ldp_vc", "ldp_vp", "JWT"]
+        }
+      },
+      "required": ["id", "path", "format"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["presentation_submission"]
+}

package/src/controllers/vn-api/schemas/velocity-presentation-submission.response.200.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Velocity Presentation Submission Response",
+  "$id": "https://velocitycareerlabs.io/velocity-presentation-submission-response.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "token": {
+      "type": "string"
+    },
+    "exchange": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "ISSUING",
+            "DISCLOSURE"
+          ]
+        },
+        "disclosureComplete": {
+          "type": "boolean"
+        },
+        "exchangeComplete": {
+          "type": "boolean"
+        }
+      },
+      "required": ["id","type", "disclosureComplete", "exchangeComplete"]
+    }
+  },
+  "required": ["exchange"]
+}

package/src/controllers/vn-api/schemas/velocity-presentation-submission.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Velocity Presentation Submission",
+  "$id": "https://velocitycareerlabs.io/velocity-presentation-submission.schema.json",
+  "type": "object",
+  "allOf": [
+    {
+      "$ref": "https://velocitycareerlabs.io/presentation-submission.schema.json#"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "issuanceDate": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "vendorOriginContext": {
+          "type": "string"
+        }
+      }
+    }
+  ],
+  "required": [
+    "presentation_submission",
+    "id",
+    "issuanceDate"
+  ]
+}

package/src/controllers/vn-api/vn-api-presentation-controller.js

@@ -0,0 +1,158 @@
+/*
+ * Copyright 2025 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 { tenantLoaderPlugin } = require('../../entities/tenants');
+const { kmsPlugin } = require('../../entities/keys');
+const {
+  ExchangeTypes,
+  getPresentationRequest,
+  postPresentation,
+  signExchangeResponse,
+  exchangeErrorHook,
+} = require('../../entities/exchanges');
+const { generateAccessToken } = require('../../entities/tokens');
+const {
+  presentationSubmissionSchema,
+  velocityPresentationSubmissionSchema,
+  velocityPresentationSubmissionResponseSchema,
+} = require('./schemas');
+
+const vnApiPresentationController = async (fastify) => {
+  fastify
+    .register(tenantLoaderPlugin, { useDID: true })
+    .register(kmsPlugin)
+    .addSchema(presentationSubmissionSchema)
+    .addSchema(velocityPresentationSubmissionSchema)
+    .addSchema(velocityPresentationSubmissionResponseSchema)
+    .get(
+      '/r/:tenantId/get-presentation-request',
+      {
+        schema: fastify.autoSchema({
+          params: {
+            type: 'object',
+            properties: {
+              tenantId: { type: 'string' },
+            },
+          },
+          query: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              vendorOriginContext: { type: 'string' },
+              'push_delegate.push_token': { type: 'string' },
+              'push_delegate.push_url': { type: 'string' },
+              format: { type: 'string', enum: ['json', 'jwt'], default: 'jwt' },
+            },
+            required: ['id'],
+          },
+          response: {
+            200: {
+              oneOf: [
+                {
+                  presentation_request: { type: 'object' },
+                },
+                {
+                  presentation_request: { type: 'string' },
+                },
+              ],
+            },
+          },
+        }),
+      },
+      // eslint-disable-next-line complexity
+      async (req) => {
+        const { query } = req;
+
+        const messagingSettings =
+          query.push_delegate?.push_url != null ||
+          query.push_delegate?.push_token != null
+            ? {
+                webhookUrl: query.push_delegate?.push_url,
+                authToken: query.push_delegate?.push_token,
+              }
+            : undefined;
+
+        const presentationRequest = await getPresentationRequest(
+          query.id,
+          query.locale,
+          messagingSettings,
+          query.vendorOriginContext,
+          req,
+        );
+
+        /* eslint-disable camelcase */
+        const presentation_request =
+          query.format !== 'json'
+            ? await signExchangeResponse(presentationRequest, {}, req)
+            : presentationRequest;
+
+        return { presentation_request };
+        /* eslint-enable */
+      },
+    )
+    .post(
+      '/r/:tenantId/presentation',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              exchange_id: { type: 'string', description: 'exchange id value' },
+              jwt_vp: {
+                type: 'string',
+                description: 'vp encoded as a jwt signed by the holder',
+              },
+            },
+            required: ['exchange_id', 'jwt_vp'],
+          },
+          response: {
+            200: {
+              $ref: 'https://velocitycareerlabs.io/velocity-presentation-submission-response.schema.json#',
+            },
+            ...fastify.UnauthorizedResponse,
+          },
+        }),
+        onError: async (req, reply, err) =>
+          exchangeErrorHook(req.body.exchange_id, err, req),
+      },
+      async (req) => {
+        const [relyingPartyService, exchange] = await postPresentation(
+          req.body.exchange_id,
+          req.body.jwt_vp,
+          req,
+        );
+
+        const token = await generateAccessToken(
+          relyingPartyService,
+          exchange,
+          req,
+        );
+
+        return {
+          token,
+          exchange: {
+            id: exchange._id,
+            type:
+              exchange.type === ExchangeTypes.ISSUER ? 'ISSUING' : 'DISCLOSURE',
+            disclosureComplete: true,
+            exchangeComplete: true,
+          },
+        };
+      },
+    );
+};
+
+module.exports = vnApiPresentationController;