@verii/server-credentialing-hub 2.0.0

package/src/controllers/operator/credentials/schemas/new-credential.schema.json

@@ -0,0 +1,23 @@
+{
+  "type": "object",
+  "$id": "new-credential",
+  "properties": {
+    "credentialReference": {
+      "type": "string",
+      "description": "reference for the offer in the host system"
+    },
+    "content": {
+      "$ref": "https://velocitycareerlabs.io/w3c-vc.schema.json"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "credentialReference",
+    "content"
+  ]
+}

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

@@ -0,0 +1,154 @@
+/*
+ * 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 { tenantLoaderPlugin } = require('../../../entities/tenants');
+const { createDepot, deleteDepot } = require('../../../entities/depots');
+const { depotSchema, newDepotSchema } = require('./schemas');
+
+const depotsController = async (fastify) => {
+  fastify
+    .addSchema(newDepotSchema)
+    .addSchema(depotSchema)
+    .register(tenantLoaderPlugin, { notFoundStatusCode: 400 })
+    .post(
+      '/create',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                type: 'string',
+              },
+              depot: { $ref: 'new-depot' },
+            },
+            required: ['tenantId', 'serviceId', 'depot'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                depot: {
+                  $ref: 'depot#',
+                },
+                requestId: {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const { depot: newDepot, serviceId } = req.body;
+        const depot = await createDepot(newDepot, serviceId, req);
+        return { depot };
+      },
+    )
+    .get(
+      '/get',
+      {
+        schema: fastify.autoSchema({
+          query: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                type: 'string',
+              },
+              depotId: {
+                anyOf: [
+                  { type: 'string' },
+                  {
+                    type: 'array',
+                    items: {
+                      type: 'string',
+                    },
+                  },
+                ],
+              },
+            },
+            required: ['tenantId'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                depots: {
+                  type: 'array',
+                  items: {
+                    $ref: 'depot',
+                  },
+                },
+                requestId: { type: 'string' },
+              },
+              required: ['depots', 'requestId'],
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const { serviceId, depotId: depotIds } = req.query;
+        const depots = await req.repos.depots.findDepots(
+          serviceId,
+          coerceArray(depotIds),
+        );
+        return { depots };
+      },
+    )
+    .post(
+      '/delete',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                type: 'string',
+                minLength: 1,
+              },
+              depotId: {
+                type: 'string',
+                minLength: 1,
+              },
+            },
+            required: ['tenantId', 'serviceId', 'depotId'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                requestId: { type: 'string' },
+              },
+              required: ['requestId'],
+            },
+          },
+        }),
+      },
+      async (req) => deleteDepot(req.body.depotId, req.body.serviceId, req),
+    );
+};
+
+module.exports = depotsController;

package/src/controllers/operator/depots/schemas/depot.schema.js

@@ -0,0 +1,34 @@
+const { mutableEntitySchema } = require('@verii/common-schemas');
+const newDepot = require('./new-depot.schema.json');
+
+const depotSchema = {
+  $id: 'depot',
+  required: [
+    ...mutableEntitySchema.required,
+    ...newDepot.required,
+    'serviceId',
+  ],
+  type: 'object',
+  properties: {
+    ...mutableEntitySchema.properties,
+    ...newDepot.properties,
+    serviceId: {
+      type: 'string',
+      description: 'the serviceId this depot is used for',
+    },
+    messagingSettings: {
+      type: 'object',
+      description: 'the wallet messaging settings',
+      properties: {
+        webhookUrl: {
+          type: 'string',
+        },
+        authToken: {
+          type: 'string',
+        },
+      },
+    },
+  },
+};
+
+module.exports = depotSchema;

package/src/controllers/operator/depots/schemas/index.js

@@ -0,0 +1,24 @@
+/*
+ * 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 depotSchema = require('./depot.schema');
+const newDepotSchema = require('./new-depot.schema.json');
+
+module.exports = {
+  newDepotSchema,
+  depotSchema,
+};

package/src/controllers/operator/depots/schemas/new-depot.schema.json

@@ -0,0 +1,30 @@
+{
+  "$id": "new-depot",
+  "type": "object",
+  "required": [
+    "userReference"
+  ],
+  "properties": {
+    "userReference": {
+      "type": "string",
+      "description": "The internal user reference for this depot. Typically a employee or student id of the system"
+    },
+    "authValues": {
+      "type": "array",
+      "description": "auth values to use for authenticating the user or session",
+      "items": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "string"
+          },
+          {
+            "type": "boolean"
+          }
+        ]
+      }
+    }
+  }
+}

package/src/controllers/operator/issue-links/issue-links-controller.js

@@ -0,0 +1,74 @@
+/*
+ * 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 { refreshIssueLinks } = require('../../../entities/links');
+const { tenantLoaderPlugin } = require('../../../entities/tenants');
+
+const issueLinksController = async (fastify) => {
+  fastify.register(tenantLoaderPlugin, { notFoundStatusCode: 400 }).post(
+    '/refresh',
+    {
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          properties: {
+            tenantId: {
+              type: 'string',
+            },
+            serviceId: {
+              type: 'string',
+            },
+            depotId: {
+              type: 'string',
+            },
+          },
+          required: ['tenantId', 'serviceId'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              redirectUrl: {
+                type: 'string',
+                format: 'uri',
+              },
+              vnProtocolLink: {
+                type: 'string',
+                format: 'uri',
+              },
+              openidCredentialOffer: {
+                type: 'string',
+                format: 'uri',
+              },
+              preauthCode: {
+                type: 'string',
+                format: 'uri',
+              },
+              requestId: {
+                type: 'string',
+                format: 'uri',
+              },
+            },
+            required: ['redirectUrl', 'vnProtocolLink', 'requestId'],
+          },
+        },
+      }),
+    },
+    async (req) => refreshIssueLinks(req.body.serviceId, req.body.depotId, req),
+  );
+};
+
+module.exports = issueLinksController;

package/src/controllers/operator/issuer-services/issuer-services-controller.js

@@ -0,0 +1,200 @@
+/*
+ * 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 { tenantLoaderPlugin } = require('../../../entities/tenants');
+const { validateIssuerService } = require('../../../entities/issuer-services');
+const {
+  createServiceConfiguration,
+  deleteServiceConfiguration,
+  updateServiceConfiguration,
+  validateUpdateServiceConfiguration,
+} = require('../../../entities/service-configurations');
+const {
+  issuerConfigurationSchema,
+  newIssuerConfigurationSchema,
+} = require('./schemas');
+
+const REPO_NAME = 'issuerServices';
+const createIssuerServiceConfiguration = createServiceConfiguration(
+  REPO_NAME,
+  validateIssuerService,
+);
+const updateIssuerServiceConfiguration = updateServiceConfiguration(
+  REPO_NAME,
+  validateUpdateServiceConfiguration(validateIssuerService),
+);
+const deleteIssuerServiceConfiguration = deleteServiceConfiguration(REPO_NAME);
+
+module.exports = async (fastify) => {
+  fastify
+    .addSchema(issuerConfigurationSchema)
+    .addSchema(newIssuerConfigurationSchema)
+    .register(tenantLoaderPlugin, { notFoundStatusCode: 400 })
+    .post(
+      '/create',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              service: {
+                $ref: 'new-issuer-service',
+              },
+            },
+            required: ['tenantId', 'service'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                service: { $ref: 'issuer-service' },
+                requestId: { type: 'string' },
+              },
+              required: ['service', 'requestId'],
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const service = await createIssuerServiceConfiguration(
+          req.body.service,
+          req,
+        );
+        return { service };
+      },
+    )
+    .get(
+      '/get',
+      {
+        schema: fastify.autoSchema({
+          query: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                anyOf: [
+                  { type: 'string' },
+                  {
+                    type: 'array',
+                    items: {
+                      type: 'string',
+                    },
+                  },
+                ],
+              },
+            },
+            required: ['tenantId'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                services: {
+                  type: 'array',
+                  items: {
+                    $ref: 'issuer-service',
+                  },
+                },
+                requestId: { type: 'string' },
+              },
+              required: ['services', 'requestId'],
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const { query, repos } = req;
+        const services = await repos.issuerServices.findServices(
+          coerceArray(query.serviceId),
+        );
+        return { services };
+      },
+    )
+    .post(
+      '/update',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                type: 'string',
+              },
+              service: {
+                $ref: 'new-issuer-service',
+              },
+            },
+            required: ['tenantId', 'serviceId', 'service'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                service: { $ref: 'issuer-service' },
+                requestId: { type: 'string' },
+              },
+              required: ['service', 'requestId'],
+            },
+          },
+        }),
+      },
+      async (req) => {
+        const service = await updateIssuerServiceConfiguration(
+          req.body.serviceId,
+          req.body.service,
+          req,
+        );
+        return { service };
+      },
+    )
+    .post(
+      '/delete',
+      {
+        schema: fastify.autoSchema({
+          body: {
+            type: 'object',
+            properties: {
+              tenantId: {
+                type: 'string',
+              },
+              serviceId: {
+                type: 'string',
+              },
+            },
+            required: ['tenantId', 'serviceId'],
+          },
+          response: {
+            200: {
+              type: 'object',
+              properties: {
+                requestId: { type: 'string' },
+              },
+            },
+          },
+        }),
+      },
+      async (req) => deleteIssuerServiceConfiguration(req.body.serviceId, req),
+    );
+};

package/src/controllers/operator/issuer-services/schemas/index.js

@@ -0,0 +1,7 @@
+const newIssuerConfigurationSchema = require('./new-issuer-service.schema');
+const issuerConfigurationSchema = require('./issuer-service.schema');
+
+module.exports = {
+  issuerConfigurationSchema,
+  newIssuerConfigurationSchema,
+};

package/src/controllers/operator/issuer-services/schemas/issuer-service.schema.js

@@ -0,0 +1,26 @@
+const { mutableEntitySchema } = require('@verii/common-schemas');
+const newIssuerConfigurationSchema = require('./new-issuer-service.schema');
+
+const issuerServiceSchema = {
+  title: 'issuer-service',
+  $id: 'issuer-service',
+  description: 'The issuer service',
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    genericRedirectUrl: {
+      type: 'string',
+      format: 'uri',
+      description:
+        'only returned if authMethod include `verifiable_presentation`',
+    },
+    ...mutableEntitySchema.properties,
+    ...newIssuerConfigurationSchema.properties,
+  },
+  required: [
+    ...mutableEntitySchema.required,
+    ...newIssuerConfigurationSchema.required,
+  ],
+};
+
+module.exports = issuerServiceSchema;