@verii/endpoints-organizations-registrar 1.0.0-pre.1752076816

package/src/entities/invitations/schemas/get-invitation-response-body.js

@@ -0,0 +1,20 @@
+const {
+  invitationResponseItemBodySchema,
+} = require('./invitation-response-item-body');
+
+const getInvitationResponseBodySchema = {
+  title: 'get-invitation-response-body',
+  $id: 'https://velocitycareerlabs.io/get-invitation-response-body.json',
+  type: 'object',
+  description: 'payload for get invitation response from registrar',
+  properties: {
+    invitation: invitationResponseItemBodySchema,
+    messageCode: {
+      type: 'string',
+      description: 'message code',
+    },
+  },
+  required: ['invitation'],
+};
+
+module.exports = { getInvitationResponseBodySchema };

package/src/entities/invitations/schemas/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./add-invitation-body'),
+  ...require('./get-invitation-response-body'),
+  ...require('./invitation-response-item-body'),
+};

package/src/entities/invitations/schemas/invitation-response-item-body.js

@@ -0,0 +1,61 @@
+const { addInvitationBodySchema } = require('./add-invitation-body');
+
+const invitationResponseItemBodySchema = {
+  $id: 'https://velocitycareerlabs.io/invitation-response-item-body.json',
+  title: 'invitation-response-item-body',
+  type: 'object',
+  description: 'payload for invitation response item from registrar',
+  properties: {
+    id: {
+      type: 'string',
+    },
+    ...addInvitationBodySchema.properties,
+    code: {
+      type: 'string',
+    },
+    inviterDid: {
+      type: 'string',
+    },
+    invitationUrl: {
+      type: 'string',
+      format: 'uri',
+    },
+    expiresAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+    acceptedAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+    acceptedBy: {
+      type: 'string',
+    },
+    createdAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+    createdBy: {
+      type: 'string',
+    },
+    updatedAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+    updatedBy: {
+      type: 'string',
+    },
+  },
+  required: [
+    'id',
+    ...addInvitationBodySchema.required,
+    'code',
+    'invitationUrl',
+    'expiresAt',
+    'createdAt',
+    'createdBy',
+    'updatedAt',
+  ],
+};
+
+module.exports = { invitationResponseItemBodySchema };

package/src/entities/kms/factories/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ *
+ */
+module.exports = { ...require('./kms-factory') };

package/src/entities/kms/factories/kms-factory.js

@@ -0,0 +1,31 @@
+/*
+ * 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 { generateKeyPair } = require('@verii/crypto');
+const { register } = require('@spencejs/spence-factories');
+const { kmsRepo } = require('@verii/db-kms');
+
+module.exports = (app) =>
+  register('kms', kmsRepo(app)({ config: app.config }), async (overrides) => {
+    const keyPair = generateKeyPair({ format: 'jwk' });
+    return {
+      publicJwk: keyPair.publicKey,
+      privateJwk: keyPair.privateKey,
+      algorithm: 'ec',
+      curve: 'secp256k1',
+      ...overrides(),
+    };
+  });

package/src/entities/monitors/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ *
+ */
+module.exports = { ...require('./orchestrators') };

package/src/entities/monitors/orchestrators/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ *
+ */
+module.exports = { ...require('./monitors') };

package/src/entities/monitors/orchestrators/monitors.js

@@ -0,0 +1,230 @@
+/*
+ * 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 { map, first, includes, isEmpty, filter } = require('lodash/fp');
+const { ServiceTypes } = require('@verii/organizations-registry');
+
+const {
+  createMonitor,
+  deleteMonitor,
+  getAllMonitors,
+  addMonitorToStatusPage,
+  serviceVersion,
+  getAllSections,
+  createSection,
+} = require('../../../fetchers');
+
+const addMonitor = async ({ orgId, orgName, service }, context) => {
+  const monitorParams = await createMonitorParams(
+    { orgId, orgName, service },
+    context
+  );
+
+  if (isEmpty(monitorParams)) {
+    return undefined;
+  }
+  const { statusPageId } = first(monitorParams);
+  const pageSection = await ensureSectionExists(
+    { orgName, statusPageId },
+    context
+  );
+
+  const monitorsAsResourceResponse = await Promise.all(
+    map(async (monitor) => createMonitor(monitor, context), monitorParams)
+  );
+
+  return Promise.all(
+    map(
+      async (monitor) =>
+        addMonitorToStatusPage(
+          {
+            resourceId: monitor.data.id,
+            publicName:
+              monitor.data.attributes.pronounceable_name.split(' : ')[1],
+            statusPageId,
+            statusPageSectionId: pageSection.id,
+          },
+          context
+        ),
+      monitorsAsResourceResponse
+    )
+  );
+};
+
+const createMonitorParams = async ({ orgId, orgName, service }, ctx) => {
+  const monitorNameTemplate = `${getMonitorPrefix(
+    ctx.config
+  )}, ${orgName}, ${orgId} : ${service.id}`;
+  const monitorParams = [];
+
+  if (service.type === ServiceTypes.CredentialAgentOperatorType) {
+    const version = await getServiceVersion(service.serviceEndpoint, ctx);
+    monitorParams.push({
+      url: service.serviceEndpoint,
+      pronounceableName: `${monitorNameTemplate}, version-${version}`,
+      monitorType: 'status',
+      statusPageId: ctx.config.servicesStatusPageId,
+    });
+  } else if (service.type === ServiceTypes.NodeOperatorType) {
+    const paramsTemplate = {
+      monitorType: 'keyword',
+      requiredKeyword: '"status" : "UP"',
+      statusPageId: ctx.config.nodesStatusPageId,
+    };
+    monitorParams.push({
+      ...paramsTemplate,
+      pronounceableName: `${monitorNameTemplate} - liveness`,
+      url: `${service.serviceEndpoint}/liveness`,
+    });
+    monitorParams.push({
+      ...paramsTemplate,
+      pronounceableName: `${monitorNameTemplate} - readiness`,
+      url: `${service.serviceEndpoint}/readiness`,
+    });
+  }
+  return monitorParams;
+};
+
+const getServiceVersion = async (url, context) => {
+  try {
+    const response = await serviceVersion(url, context);
+    const contentArray = response.body?.split('\n');
+
+    const versionMark = 'version:';
+
+    const result = filter(
+      (value) => includes(versionMark, value.toLowerCase()),
+      contentArray
+    );
+
+    if (isEmpty(result) || first(result) == null) {
+      return undefined;
+    }
+
+    return first(result).toLowerCase().replace(versionMark, '').trim();
+  } catch (error) {
+    const { log } = context;
+    log.error({ err: error }, 'Failed to retrieve service version');
+    return undefined;
+  }
+};
+
+const synchronizeMonitors = async (context) => {
+  const { repos } = context;
+  const organizations = await repos.organizations.find();
+
+  const allMonitorsResponse = await getAllMonitors(context);
+
+  return Promise.all(
+    map(
+      async (organization) =>
+        ensureMonitorsExist(organization, allMonitorsResponse.data, context),
+      organizations
+    )
+  );
+};
+
+const findMonitorByPartialMatch = (monitorsArray, { orgId, serviceId }) =>
+  filter(
+    (monitor) =>
+      includes(orgId, monitor.attributes.pronounceable_name) &&
+      includes(serviceId, monitor.attributes.pronounceable_name),
+    monitorsArray
+  );
+
+const ensureMonitorExists = async (
+  { orgId, orgName, service },
+  monitors,
+  context
+) => {
+  const monitorExist = findMonitorByPartialMatch(monitors, {
+    orgId,
+    serviceId: service.id,
+  });
+  if (isEmpty(monitorExist)) {
+    return addMonitor({ orgId, orgName, service }, context);
+  }
+  return undefined;
+};
+
+const ensureSectionExists = async ({ orgName, statusPageId }, ctx) => {
+  const pageSections = await getAllSections(statusPageId, ctx);
+
+  let pageSection = first(
+    filter(
+      (section) => includes(orgName, section.attributes.name),
+      pageSections.data
+    )
+  );
+
+  if (isEmpty(pageSection)) {
+    pageSection = (await createSection({ orgName, statusPageId }, ctx)).data;
+  }
+
+  return pageSection;
+};
+
+const ensureMonitorsExist = async (organisation, monitors, context) => {
+  const { services, didDoc } = organisation;
+
+  return Promise.all(
+    map(
+      async (service) =>
+        ensureMonitorExists(
+          { orgId: didDoc.id, orgName: organisation.profile.name, service },
+          monitors,
+          context
+        ),
+      services
+    )
+  );
+};
+
+const addMonitors = async ({ orgId, orgName, orgServices }, context) => {
+  return Promise.all(
+    map(
+      (service) => addMonitor({ orgId, orgName, service }, context),
+      orgServices
+    )
+  );
+};
+const removeMonitor = async ({ orgId, serviceId }, context) => {
+  // TODO: Currently account plan is limited by 50 monitors, once plan will be upgraded, pagination will be needed to be implemented
+  const allMonitorsResponse = await getAllMonitors(context);
+
+  const monitorsToRemove = findMonitorByPartialMatch(
+    allMonitorsResponse?.data,
+    { orgId, serviceId }
+  );
+
+  return Promise.all(
+    map(
+      async (monitor) => deleteMonitor({ monitorId: monitor.id }, context),
+      monitorsToRemove
+    )
+  );
+};
+
+const getMonitorPrefix = ({ nodeEnv }) => {
+  return nodeEnv.toUpperCase();
+};
+
+module.exports = {
+  addMonitors,
+  removeMonitor,
+  synchronizeMonitors,
+};

package/src/entities/oauth/domain/constants.js

@@ -0,0 +1,23 @@
+const VNF_GROUP_ID_CLAIM = 'http://velocitynetwork.foundation/groupId';
+
+const AuthClientTypes = {
+  CAO_NODE_CLIENT: 'agent',
+  REGISTRAR: 'registrar',
+  NODE_OPERATOR: 'node',
+};
+
+const RoleNames = {
+  Superuser: 'superuser',
+  RegistrarClientAdmin: 'clientadmin',
+  TokenWalletClientFinanceAdmin: 'clientfinanceadmin',
+  TokenWalletClientSystemUser: 'clientsystemuser',
+  FineractOperationsUser: 'operations',
+  FineractBrokerUser: 'broker',
+  FineractRegistrarUser: 'registrar',
+};
+
+module.exports = {
+  VNF_GROUP_ID_CLAIM,
+  AuthClientTypes,
+  RoleNames,
+};

package/src/entities/oauth/domain/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./constants'),
+  ...require('./roles'),
+  ...require('./scopes'),
+};

package/src/entities/oauth/domain/roles.js

@@ -0,0 +1,92 @@
+/*
+ * 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 { reduce, flow, map } = require('lodash/fp');
+const { RoleNames } = require('./constants');
+
+const initRoleIdToRoleName = ({
+  auth0SuperuserRoleId,
+  auth0ClientAdminRoleId,
+  auth0ClientFinanceAdminRoleId,
+  auth0ClientSystemUserRoleId,
+}) => {
+  return (roleId) => {
+    switch (roleId) {
+      case auth0SuperuserRoleId:
+        return RoleNames.Superuser;
+      case auth0ClientFinanceAdminRoleId:
+        return RoleNames.TokenWalletClientFinanceAdmin;
+      case auth0ClientSystemUserRoleId:
+        return RoleNames.TokenWalletClientSystemUser;
+      case auth0ClientAdminRoleId:
+      default:
+        return RoleNames.RegistrarClientAdmin;
+    }
+  };
+};
+
+const roleObjMapping = {
+  registrarRole: {
+    [RoleNames.RegistrarClientAdmin]: true,
+    [RoleNames.Superuser]: true,
+  },
+  tokenWalletRole: {
+    [RoleNames.TokenWalletClientFinanceAdmin]: true,
+    [RoleNames.TokenWalletClientSystemUser]: true,
+  },
+};
+
+const roleNamesToRoleObj = (roleNames) => {
+  return reduce(
+    (roleObj, currentRoleName) => {
+      return {
+        registrarRole: roleObjMapping.registrarRole[currentRoleName]
+          ? currentRoleName
+          : roleObj.registrarRole,
+        tokenWalletRole: roleObjMapping.tokenWalletRole[currentRoleName]
+          ? currentRoleName
+          : roleObj.tokenWalletRole,
+      };
+    },
+    {
+      registrarRole: undefined,
+      tokenWalletRole: undefined,
+    },
+    roleNames
+  );
+};
+
+const initAuth0RoleArrToRolesObj = ({
+  auth0SuperuserRoleId,
+  auth0ClientAdminRoleId,
+  auth0ClientFinanceAdminRoleId,
+  auth0ClientSystemUserRoleId,
+}) => {
+  const roleIdToRoleName = initRoleIdToRoleName({
+    auth0SuperuserRoleId,
+    auth0ClientAdminRoleId,
+    auth0ClientFinanceAdminRoleId,
+    auth0ClientSystemUserRoleId,
+  });
+  return flow(map('id'), map(roleIdToRoleName), roleNamesToRoleObj);
+};
+
+module.exports = {
+  initRoleIdToRoleName,
+  roleNamesToRoleObj,
+  initAuth0RoleArrToRolesObj,
+};

package/src/entities/oauth/domain/scopes.js

@@ -0,0 +1,35 @@
+const { initHasMatchingScope } = require('@verii/auth');
+
+const RegistrarScopes = {
+  AdminOrganizations: 'admin:organizations',
+  WriteOrganizations: 'write:organizations',
+  ReadOrganizations: 'read:organizations',
+  AdminUsers: 'admin:users',
+  WriteUsers: 'write:users',
+  ReadUsers: 'read:users',
+  EventsTrigger: 'events:trigger',
+};
+
+const hasAdminOrganizationScope = initHasMatchingScope([
+  RegistrarScopes.AdminOrganizations,
+]);
+const hasReadOrganizationScope = initHasMatchingScope([
+  RegistrarScopes.ReadOrganizations,
+]);
+const hasWriteOrganizationScope = initHasMatchingScope([
+  RegistrarScopes.WriteOrganizations,
+]);
+
+const hasWriteUsersScope = initHasMatchingScope([RegistrarScopes.WriteUsers]);
+const hasReadUsersScope = initHasMatchingScope([RegistrarScopes.ReadUsers]);
+const hasAdminUsersScope = initHasMatchingScope([RegistrarScopes.AdminUsers]);
+
+module.exports = {
+  RegistrarScopes,
+  hasAdminOrganizationScope,
+  hasWriteOrganizationScope,
+  hasReadOrganizationScope,
+  hasAdminUsersScope,
+  hasWriteUsersScope,
+  hasReadUsersScope,
+};

package/src/entities/oauth/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('./domain'),
+  ...require('./orchestrators'),
+};