@verii/server-credentialagent 1.0.0-pre.1752076816

package/src/controllers/operator/tenants/schemas/secret-key-metadata.schema.json

@@ -0,0 +1,31 @@
+{
+  "title": "secret-key",
+  "$id": "https://velocitycareerlabs.io/secret-key-metadata.schema.json",
+  "type": "object",
+  "description": "metadata of a given secret key",
+  "properties": {
+    "purposes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    },
+    "algorithm": {
+      "type": "string",
+      "default": "SECP256K1"
+    },
+    "encoding": {
+      "type": "string"
+    },
+    "kidFragment": {
+      "type": "string",
+      "pattern": "^#.+$"
+    }
+  },
+  "required": [
+    "purposes",
+    "encoding",
+    "kidFragment"
+  ]
+}

package/src/controllers/operator/tenants/schemas/secret-key.schema.json

@@ -0,0 +1,29 @@
+{
+  "title": "secret-key",
+  "$id": "https://velocitycareerlabs.io/secret-key.schema.json",
+  "type": "object",
+  "description": "a secret key",
+  "anyOf": [
+    {
+      "properties": {
+        "key": {
+          "type": "string"
+        }
+      }
+    },
+    {
+      "properties": {
+        "jwk": {
+          "type": "object"
+        }
+      }
+    },
+    {
+      "properties": {
+        "hexKey": {
+          "type": "string"
+        }
+      }
+    }
+  ]
+}

package/src/controllers/operator/tenants/schemas/secret-kid.schema.json

@@ -0,0 +1,13 @@
+{
+  "title": "secret-kid",
+  "$id": "https://velocitycareerlabs.io/secret-kid.schema.json",
+  "type": "object",
+  "description": "a secret's key id",
+  "properties": {
+    "kid": {
+      "type": "string",
+      "description": "in the velocity network a kid is always the a did fragment. See https://www.w3.org/TR/did-core/#fragment"
+    }
+  },
+  "required": ["kid"]
+}

package/src/controllers/operator/tenants/schemas/secret-new-tenant-v0.8.schema.json

@@ -0,0 +1,28 @@
+{
+  "title": "secret-new-tenant",
+  "$id": "https://velocitycareerlabs.io/secret-new-tenant-v0.8.schema.json",
+  "type": "object",
+  "description": "",
+  "allOf": [
+    {
+      "$ref": "https://velocitycareerlabs.io/new-tenant-v0.8.schema.json#"
+    },
+    {
+      "properties": {
+        "keys": {
+          "type": "array",
+          "items": {
+            "allOf": [
+              {
+                "$ref": "https://velocitycareerlabs.io/secret-key-metadata.schema.json#"
+              },
+              {
+                "$ref": "https://velocitycareerlabs.io/secret-key.schema.json#"
+              }
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/src/controllers/operator/tenants/schemas/secret-tenant-key-v0.8.schema.json

@@ -0,0 +1,13 @@
+{
+  "title": "secret-tenant-key",
+  "$id": "https://velocitycareerlabs.io/secret-tenant-key-v0.8.schema.json",
+  "description": "",
+  "allOf": [
+    {
+      "$ref": "https://velocitycareerlabs.io/secret-key-metadata.schema.json#"
+    },
+    {
+      "$ref": "https://velocitycareerlabs.io/secret-key.schema.json#"
+    }
+  ]
+}

package/src/controllers/operator/tenants/schemas/tenant-key-v0.8.schema.json

@@ -0,0 +1,14 @@
+{
+  "title": "tenant-key",
+  "$id": "https://velocitycareerlabs.io/tenant-key-v0.8.schema.json",
+  "description": "",
+  "allOf": [
+    {
+      "$ref": "https://velocitycareerlabs.io/secret-key-metadata.schema.json#"
+    },
+    {
+      "$ref": "immutable-entity#"
+    }
+  ],
+  "additionalProperties": false
+}

package/src/controllers/operator/tenants/schemas/tenant-v0.8.schema.json

@@ -0,0 +1,62 @@
+{
+  "title": "tenant",
+  "$id": "https://velocitycareerlabs.io/tenant-v0.8.schema.json",
+  "description": "",
+  "allOf": [
+    { "$ref": "mutable-entity#"},
+    {
+      "properties": {
+        "did": {
+          "type": "string",
+          "pattern": "^did:[a-z0-9]+:[A-Za-z0-9._:?=&%;-]+$"
+        },
+        "serviceIds": {
+          "type": "array",
+          "description": "id's of the service",
+          "items": {
+            "type": "string",
+            "pattern": "^did:[a-z0-9]+:[A-Za-z0-9._:?=&%;-]+#[A-Za-z0-9._:?=&%;-]+$"
+          }
+        },
+        "logo": {
+          "type": "string",
+          "format": "uri"
+        },
+        "webhookUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "name": {
+          "type": "string",
+          "description": "did for the org"
+        },
+        "primaryAddress": {
+          "type": "string",
+          "description": "ethereum primary address of tenant"
+        },
+        "description": {
+          "type": "string",
+          "description": "did for the org"
+        },
+        "credentialTypesIssued": {
+          "type": "array",
+          "description": "credential types that are issued",
+          "items": {
+            "type": "string"
+          }
+        },
+        "webhookAuth": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type":"string",
+              "enums": ["bearer"]
+            }
+          }
+        }
+      }
+    }
+  ],
+  "required": ["did"],
+  "additionalProperties": false
+}

package/src/controllers/root/autohooks.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.
+ */
+
+module.exports = async (fastify) => {
+  fastify
+    .decorateRequest('registrarFetch', null)
+    .addHook('preValidation', async (req) => {
+      req.registrarFetch = fastify.baseRegistrarFetch(req);
+    });
+};

package/src/controllers/root/controller.js

@@ -0,0 +1,173 @@
+/**
+ * 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 path = require('path');
+const {
+  map,
+  flow,
+  zip,
+  range,
+  forEach,
+  isEmpty,
+  values,
+} = require('lodash/fp');
+const { nanoid } = require('nanoid');
+const fastifyView = require('@fastify/view');
+const { appendSearchParam } = require('@verii/common-functions');
+const handlebars = require('handlebars');
+const Error = require('http-errors');
+
+const { createDeepLinkUrl, EXCHANGE_TYPE } = require('../../entities');
+
+const appRedirectController = async (fastify) => {
+  fastify.register(fastifyView, {
+    engine: {
+      handlebars,
+    },
+    root: path.join(__dirname, '../../assets/templates'),
+  });
+  fastify
+    .get(
+      '/',
+      {
+        schema: {
+          description: 'Healthcheck and version info',
+          responses: {
+            200: {
+              description: 'Successful response',
+              content: { 'text/plain': { schema: { type: 'string' } } },
+            },
+          },
+          tags: ['utilities'],
+        },
+      },
+      async (req, reply) => {
+        reply
+          .status(200)
+          .send(
+            `Welcome to Credential APIs\nHost: ${fastify.config.hostUrl}\nVersion: ${fastify.config.version}\n`
+          );
+      }
+    )
+    .get(
+      '/app-redirect',
+      {
+        schema: fastify.autoSchema({
+          querystring: {
+            type: 'object',
+            properties: {
+              exchange_type: {
+                type: 'string',
+                enum: values(EXCHANGE_TYPE),
+              },
+              request_uri: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              vendorOriginContext: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              inspectorDid: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['request_uri', 'exchange_type'],
+          },
+          response: {
+            200: {
+              description: 'deep link redirection page',
+              content: {
+                'text/html': { schema: { type: 'string' } },
+              },
+            },
+          },
+        }),
+      },
+      async (req, reply) => {
+        const {
+          query: { exchange_type: exchangeType, inspectorDid },
+        } = req;
+
+        validateInspectorDid({ exchangeType, inspectorDid });
+
+        const { deeplink } = processingLinks(req);
+
+        const { libUrl } = fastify.config;
+
+        const scriptUrl = `${libUrl}/vnf-wallet-selection/index.js`;
+        const styleSheetUrl = `${libUrl}/vnf-wallet-selection/site.css`;
+        const resourceNonce = nanoid();
+
+        const cspScriptSrc = `script-src 'nonce-${resourceNonce}';`;
+        const cspStyleSrc = `style-src 'nonce-${resourceNonce}';`;
+        const csp = `${cspStyleSrc} ${cspScriptSrc}`;
+        reply.header('Content-Security-Policy', csp);
+        return reply.view('app-redirect', {
+          deeplink,
+          scriptUrl,
+          scriptNonce: resourceNonce,
+          styleSheetUrl,
+        });
+      }
+    );
+};
+
+const validateInspectorDid = ({ exchangeType, inspectorDid }) => {
+  if (exchangeType === EXCHANGE_TYPE.inspect && isEmpty(inspectorDid)) {
+    throw new Error.BadRequest(
+      'inspectorDid should be present for exchange_type = "inspect"'
+    );
+  }
+  if (exchangeType === EXCHANGE_TYPE.issue && !isEmpty(inspectorDid)) {
+    throw new Error.BadRequest(
+      'inspectorDid should not be present for exchange_type = "issue"'
+    );
+  }
+};
+
+const processingLinks = (context) => {
+  const {
+    query: {
+      exchange_type: exchangeType,
+      request_uri: requestUriItems,
+      inspectorDid: inspectorDidItems = [],
+      vendorOriginContext: vendorOriginContextItems = [],
+    },
+  } = context;
+
+  const parsedLinks = flow(
+    (items) => zip(items, range(0, items.length)),
+    map(([value, index]) => ({
+      requestUri: value,
+      vendorOriginContext: vendorOriginContextItems[index],
+      inspectorDid: inspectorDidItems[index],
+    }))
+  )(requestUriItems);
+
+  const deeplink = createDeepLinkUrl(exchangeType, context);
+  forEach(({ requestUri, inspectorDid, vendorOriginContext }) => {
+    flow(
+      appendSearchParam('request_uri', requestUri),
+      appendSearchParam('inspectorDid', inspectorDid),
+      appendSearchParam('vendorOriginContext', vendorOriginContext)
+    )(deeplink);
+  }, parsedLinks);
+
+  return { deeplink };
+};
+
+// eslint-disable-next-line better-mutation/no-mutation
+appRedirectController.prefixOverride = '';
+
+module.exports = appRedirectController;

package/src/controllers/saasoperator/groups/_id/autohooks.js

@@ -0,0 +1,9 @@
+module.exports = async (fastify) => {
+  fastify.autoSchemaPreset({
+    params: {
+      type: 'object',
+      properties: { id: { type: 'string', minLength: 1 } },
+      required: ['id'],
+    },
+  });
+};

package/src/controllers/saasoperator/groups/_id/controller.js

@@ -0,0 +1,121 @@
+const newError = require('http-errors');
+const { isEmpty } = require('lodash/fp');
+const {
+  formatGroup,
+  validateGroup,
+  findGroupOrError,
+  validateDid,
+} = require('../../../../entities');
+const { groupSchema } = require('../schemas');
+
+const controller = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              group: groupSchema,
+            },
+            required: ['group'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { params } = req;
+      const group = await findGroupOrError(params.id, req);
+      return { group: formatGroup(group) };
+    }
+  );
+
+  fastify.delete(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          204: { type: 'null' },
+          400: { $ref: 'error#' },
+        },
+      }),
+    },
+    async (req, rep) => {
+      const { params, repos } = req;
+
+      const group = await findGroupOrError(params.id, req);
+      if (!isEmpty(group.dids)) {
+        throw newError(400, 'Group has tenants associated with it', {
+          errorCode: 'group_has_tenants',
+        });
+      }
+      await repos.groups.del(params.id);
+      rep.code(204);
+    }
+  );
+
+  fastify.put(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            slug: { type: 'string', minLength: 1, pattern: '^[a-z0-9_-]*' },
+          },
+          required: ['slug'],
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              group: groupSchema,
+            },
+            required: ['group'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos, body, params } = req;
+      await validateGroup(body, req);
+      const updatedGroup = await repos.groups.updateOrError(params.id, {
+        $set: { slug: body.slug },
+      });
+      return { group: formatGroup(updatedGroup) };
+    }
+  );
+
+  fastify.post(
+    '/add-did',
+    {
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            did: { type: 'string' },
+          },
+          required: ['did'],
+        },
+        response: {
+          204: { type: 'null' },
+        },
+      }),
+    },
+    async (req, rep) => {
+      const { repos, body, params } = req;
+      const { id } = params;
+      const { did } = body;
+      await validateDid(id, did, req);
+      await repos.groups.updateOrError(id, {
+        $addToSet: { dids: did },
+      });
+      rep.code(204).send();
+    }
+  );
+};
+
+module.exports = controller;

package/src/controllers/saasoperator/groups/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.addHook('preHandler', fastify.verifyAdmin);
+};

package/src/controllers/saasoperator/groups/controller.js

@@ -0,0 +1,65 @@
+const { map, omit } = require('lodash/fp');
+const { newGroupSchema, groupSchema } = require('./schemas');
+const { formatGroup } = require('../../../entities');
+const { validateGroup } = require('../../../entities/groups/orchestrators');
+
+const controller = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              groups: {
+                type: 'array',
+                items: groupSchema,
+              },
+            },
+            required: ['groups'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos } = req;
+      const groups = await repos.groups.find();
+      return {
+        groups: map(formatGroup, groups),
+      };
+    }
+  );
+
+  fastify.post(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        body: newGroupSchema,
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              group: groupSchema,
+            },
+            required: ['group'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { body, repos } = req;
+      await validateGroup(body, req);
+
+      const newGroup = await repos.groups.insert({
+        ...omit(['did'], body),
+        _id: body.did,
+      });
+      return {
+        group: formatGroup(newGroup),
+      };
+    }
+  );
+};
+
+module.exports = controller;

package/src/controllers/saasoperator/groups/schemas/group.schema.js

@@ -0,0 +1,17 @@
+module.exports = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://velocitycareerlabs.io/group.schema.json',
+  title: 'group',
+  description: 'An group',
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    id: { type: 'string' },
+    did: { type: 'string' },
+    slug: { type: 'string' },
+    dids: { type: 'array', items: { type: 'string' } },
+    createdAt: { type: 'string', format: 'date-time' },
+    updatedAt: { type: 'string', format: 'date-time' },
+  },
+  required: ['id', 'slug'],
+};

package/src/controllers/saasoperator/groups/schemas/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  newGroupSchema: require('./new-group.schema'),
+  groupSchema: require('./group.schema'),
+};

package/src/controllers/saasoperator/groups/schemas/new-group.schema.js

@@ -0,0 +1,13 @@
+module.exports = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://velocitycareerlabs.io/new-group.schema.json',
+  title: 'new-group',
+  description: 'An new group',
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    slug: { type: 'string', minLength: 1, pattern: '^[a-z0-9_-]*' },
+    did: { type: 'string', minLength: 1 },
+  },
+  required: ['slug', 'did'],
+};

package/src/entities/common/domains/get-json-at-path.js

@@ -0,0 +1,28 @@
+/**
+ * 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 { JSONPath } = require('jsonpath-plus');
+
+const getJsonAtPath = (path, json) =>
+  JSONPath({
+    path,
+    json,
+    preventEval: true,
+  });
+
+module.exports = {
+  getJsonAtPath,
+};