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

package/src/entities/organization-services/domains/build-organizations-services.js

@@ -0,0 +1,38 @@
+const { map, pick } = require('lodash/fp');
+const { toRelativeServiceId } = require('@verii/did-doc');
+
+const ImmutableOrganizationServiceProperties = [
+  'id',
+  'type',
+  'invitationId',
+  'createdAt',
+  'updatedAt',
+];
+
+const buildOrganizationServiceForUpdate = (updates, existingService) => {
+  return {
+    ...updates,
+    ...pick(ImmutableOrganizationServiceProperties, existingService),
+  };
+};
+
+const buildOrganizationService = (service, invitation) => {
+  const organizationService = {
+    ...service,
+    id: toRelativeServiceId(service.id),
+  };
+  if (invitation != null) {
+    // eslint-disable-next-line better-mutation/no-mutation
+    organizationService.invitationId = invitation._id;
+  }
+  return organizationService;
+};
+
+const buildOrganizationServices = (services, invitation) =>
+  map((service) => buildOrganizationService(service, invitation), services);
+
+module.exports = {
+  buildOrganizationServices,
+  buildOrganizationService,
+  buildOrganizationServiceForUpdate,
+};

package/src/entities/organization-services/domains/build-public-services.js

@@ -0,0 +1,19 @@
+const { map, pick } = require('lodash/fp');
+
+const buildPublicService = pick([
+  'id',
+  'type',
+  'serviceEndpoint',
+  'credentialTypes',
+  'logoUrl',
+  'playStoreUrl',
+  'appleAppStoreUrl',
+  'appleAppId',
+  'googlePlayId',
+  'name',
+  'supportedExchangeProtocols',
+]);
+
+const buildPublicServices = map(buildPublicService);
+
+module.exports = { buildPublicServices, buildPublicService };

package/src/entities/organization-services/domains/constants.js

@@ -0,0 +1,32 @@
+const {
+  ServiceCategories,
+  ServiceTypesOfServiceCategory,
+} = require('@verii/organizations-registry');
+
+const didDocServiceFields = ['id', 'type', 'serviceEndpoint'];
+
+const identityCategories = [
+  ...ServiceTypesOfServiceCategory[ServiceCategories.IdDocumentIssuer],
+  ...ServiceTypesOfServiceCategory[ServiceCategories.NotaryIdDocumentIssuer],
+  ...ServiceTypesOfServiceCategory[ServiceCategories.ContactIssuer],
+  ...ServiceTypesOfServiceCategory[ServiceCategories.NotaryContactIssuer],
+  ...ServiceTypesOfServiceCategory[ServiceCategories.IdentityIssuer],
+];
+
+const NodeServiceCategories = [
+  ...ServiceTypesOfServiceCategory[ServiceCategories.NodeOperator],
+  ...ServiceTypesOfServiceCategory[ServiceCategories.CredentialAgentOperator],
+];
+
+const OrganizationServiceErrorMessages = {
+  ORGANIZATION_SERVICE_NOT_FOUND: 'Organization service not found',
+  SERVICE_ID_CANNOT_BE_UPDATED: 'Service "id" property cannot be updated',
+  SERVICE_TYPE_CANNOT_BE_UPDATED: 'Service "type" property cannot be updated',
+};
+
+module.exports = {
+  didDocServiceFields,
+  identityCategories,
+  NodeServiceCategories,
+  OrganizationServiceErrorMessages,
+};

package/src/entities/organization-services/domains/extract-cao-service-refs.js

@@ -0,0 +1,10 @@
+const { flow, map, compact, uniq } = require('lodash/fp');
+const { extractServiceEndpointDid } = require('./extract-service-endpoint-did');
+
+const extractCaoServiceRefs = flow(
+  map(extractServiceEndpointDid),
+  compact,
+  uniq
+);
+
+module.exports = { extractCaoServiceRefs };

package/src/entities/organization-services/domains/extract-service-endpoint-did.js

@@ -0,0 +1,10 @@
+const { isDidUrlWithFragment } = require('@verii/did-doc');
+
+const extractServiceEndpointDid = (service) => {
+  if (isDidUrlWithFragment(service.serviceEndpoint)) {
+    return service.serviceEndpoint;
+  }
+  return undefined;
+};
+
+module.exports = { extractServiceEndpointDid };

package/src/entities/organization-services/domains/get-service-consent-type.js

@@ -0,0 +1,16 @@
+const { isCaoService, isNodeOperator } = require('./is-service-category');
+const { ConsentTypes } = require('../../registrar-consents');
+
+const getServiceConsentType = (service) => {
+  if (isCaoService(service)) {
+    return ConsentTypes.CAO;
+  }
+  if (isNodeOperator(service)) {
+    return ConsentTypes.NodeOperator;
+  }
+  return ConsentTypes.IssuerInspector;
+};
+
+module.exports = {
+  getServiceConsentType,
+};

package/src/entities/organization-services/domains/get-service-types-from-categories.js

@@ -0,0 +1,18 @@
+const { flatMap } = require('lodash/fp');
+const {
+  ServiceTypesOfServiceCategory,
+} = require('@verii/organizations-registry');
+
+const serviceCategoriesToServiceTypes = flatMap(
+  (currentServiceCategory) =>
+    ServiceTypesOfServiceCategory[currentServiceCategory]
+);
+
+const getServiceTypesFromCategories = ({ filter } = {}) => {
+  const serviceCategories = filter?.serviceTypes;
+  return serviceCategories != null
+    ? serviceCategoriesToServiceTypes(serviceCategories)
+    : undefined;
+};
+
+module.exports = { getServiceTypesFromCategories };

package/src/entities/organization-services/domains/index.js

@@ -0,0 +1,17 @@
+module.exports = {
+  ...require('./activate-services'),
+  ...require('./build-organizations-services'),
+  ...require('./build-public-services'),
+  ...require('./get-service-types-from-categories'),
+  ...require('./get-service-consent-type'),
+  ...require('./extract-cao-service-refs'),
+  ...require('./extract-service-endpoint-did'),
+  ...require('./constants'),
+  ...require('./is-service-category'),
+  ...require('./is-new-node-operator-service'),
+  ...require('./normalize-service-endpoint'),
+  ...require('./select-activated-services'),
+  ...require('./transform-profile-service'),
+  ...require('./validate-service'),
+  ...require('./validate-services-for-delete'),
+};

package/src/entities/organization-services/domains/is-new-node-operator-service.js

@@ -0,0 +1,25 @@
+/*
+ * 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 { isNodeOperator } = require('./is-service-category');
+
+const isNewNodeOperatorService = (organization, newService) =>
+  isNodeOperator(newService) && isStakesAccountMissing(organization);
+
+const isStakesAccountMissing = ({ ids }) => ids?.stakesAccountId == null;
+
+module.exports = { isNewNodeOperatorService };

package/src/entities/organization-services/domains/is-service-category.js

@@ -0,0 +1,31 @@
+const { includes } = require('lodash/fp');
+
+const {
+  ServiceTypeToCategoryMap,
+  ServiceCategories,
+  ServiceTypesOfServiceCategory,
+  IssuingAndInspectionCategories,
+} = require('@verii/organizations-registry');
+
+const isIssuingOrInspectionService = (service) =>
+  service?.type != null &&
+  includes(
+    ServiceTypeToCategoryMap[service.type],
+    IssuingAndInspectionCategories
+  );
+
+const isCaoService = (service) =>
+  service != null &&
+  includes(
+    service.type,
+    ServiceTypesOfServiceCategory[ServiceCategories.CredentialAgentOperator]
+  );
+
+const isNodeOperator = (service) =>
+  service != null &&
+  includes(
+    service.type,
+    ServiceTypesOfServiceCategory[ServiceCategories.NodeOperator]
+  );
+
+module.exports = { isIssuingOrInspectionService, isCaoService, isNodeOperator };

package/src/entities/organization-services/domains/normalize-service-endpoint.js

@@ -0,0 +1,6 @@
+const { trimEnd } = require('lodash');
+
+const normalizeServiceEndpoint = (serviceEndpoint) =>
+  `${trimEnd(serviceEndpoint, '/')}`;
+
+module.exports = { normalizeServiceEndpoint };

package/src/entities/organization-services/domains/select-activated-services.js

@@ -0,0 +1,8 @@
+const { map, find } = require('lodash/fp');
+
+const selectActivatedServices = (selectedServiceIds, services) =>
+  map((id) => find({ id }, services))(selectedServiceIds);
+
+module.exports = {
+  selectActivatedServices,
+};

package/src/entities/organization-services/domains/transform-profile-service.js

@@ -0,0 +1,88 @@
+const {
+  endsWith,
+  filter,
+  flow,
+  includes,
+  map,
+  isEmpty,
+  set,
+} = require('lodash/fp');
+const {
+  ServiceTypes,
+  ServiceTypesOfServiceCategory,
+  ServiceCategories,
+} = require('@verii/organizations-registry');
+const { isDidUrlWithFragment } = require('@verii/did-doc');
+const { buildPublicServices } = require('./build-public-services');
+const { normalizeServiceEndpoint } = require('./normalize-service-endpoint');
+
+const transformServiceEndpoint = (service, caoServiceRefs) => {
+  if (!isDidUrlWithFragment(service.serviceEndpoint)) {
+    return service;
+  }
+  const caoServiceRef = caoServiceRefs[service.serviceEndpoint];
+  if (caoServiceRef?.caoService == null) {
+    return service;
+  }
+  return set(
+    'serviceEndpoint',
+    caoServiceRef.caoService.serviceEndpoint,
+    service
+  );
+};
+
+const transformProfileService = (
+  organization,
+  services,
+  serviceTypes,
+  caoServiceRefs,
+  { query }
+) => {
+  const pipeline = [
+    buildPublicServices,
+    filter((service) => includes(service.id, organization.activatedServiceIds)),
+  ];
+  if (!isEmpty(serviceTypes)) {
+    pipeline.push(filter((service) => includes(service.type, serviceTypes)));
+  }
+  if (!query.noServiceEndpointTransform) {
+    pipeline.push(
+      map((service) => transformServiceEndpoint(service, caoServiceRefs))
+    );
+    const convertIssuerService = convertIssuer(organization.didDoc);
+    pipeline.push(map((service) => convertIssuerService(service)));
+  }
+
+  return flow(pipeline)(services);
+};
+
+const isLegacyIssuerService = (service) =>
+  [
+    ServiceTypes.IdDocumentIssuerType,
+    ServiceTypes.NotaryIdDocumentIssuerType,
+    ServiceTypes.ContactIssuerType,
+    ServiceTypes.NotaryContactIssuerType,
+    ServiceTypes.NotaryIssuerType,
+    ServiceTypes.IdentityIssuerType,
+    ...ServiceTypesOfServiceCategory[ServiceCategories.Issuer],
+  ].includes(service.type) &&
+  !endsWith('get-credential-manifest', service.serviceEndpoint);
+
+const convertIssuer = (didDoc) => (service) => {
+  const normalizedEndpoint = normalizeServiceEndpoint(service.serviceEndpoint);
+  if (
+    isDidUrlWithFragment(service.serviceEndpoint) ||
+    !isLegacyIssuerService(service)
+  ) {
+    return {
+      ...service,
+      serviceEndpoint: normalizedEndpoint,
+    };
+  }
+  return {
+    ...service,
+    serviceEndpoint: `${normalizedEndpoint}/api/holder/v0.6/org/${didDoc.id}/issue/get-credential-manifest`,
+  };
+};
+
+module.exports = { transformProfileService, convertIssuer };

package/src/entities/organization-services/domains/validate-cao-service-refs.js

@@ -0,0 +1,25 @@
+const newError = require('http-errors');
+const { isDidUrlWithFragment } = require('@verii/did-doc');
+const {
+  isIssuingOrInspectionService,
+  isCaoService,
+} = require('./is-service-category');
+
+const validateCaoServiceRefs = (service, caoServiceRefs) => {
+  if (!isDidUrlWithFragment(service.serviceEndpoint)) {
+    return;
+  }
+
+  const referencedService = caoServiceRefs[service.serviceEndpoint];
+
+  if (
+    isIssuingOrInspectionService(service) &&
+    !isCaoService(referencedService?.caoService)
+  ) {
+    throw newError(400, 'Service endpoint is not pointing to CAO', {
+      errorCode: 'service_endpoint_ref_not_found',
+    });
+  }
+};
+
+module.exports = { validateCaoServiceRefs };

package/src/entities/organization-services/domains/validate-service-credential-type.js

@@ -0,0 +1,47 @@
+const newError = require('http-errors');
+const { difference, isEmpty } = require('lodash/fp');
+const {
+  ServiceTypesOfServiceCategory,
+  ServiceCategories,
+} = require('@verii/organizations-registry');
+const { identityCategories } = require('./constants');
+
+const validateServiceCredentialType = (
+  newService,
+  { registeredCredentialTypes, config: { idCredentialTypes } }
+) => {
+  const expectedCredentialTypes = computeExpectedCredentialTypes(
+    newService.type,
+    { registeredCredentialTypes, idCredentialTypes }
+  );
+  if (expectedCredentialTypes == null) {
+    return;
+  }
+
+  const unsupportedCredentialTypes = difference(
+    newService.credentialTypes,
+    expectedCredentialTypes
+  );
+  if (!isEmpty(unsupportedCredentialTypes)) {
+    throw newError.BadRequest(
+      `Cannot add issuer that issues unsupported credential types ${unsupportedCredentialTypes}`
+    );
+  }
+};
+
+const computeExpectedCredentialTypes = (
+  type,
+  { registeredCredentialTypes, idCredentialTypes }
+) => {
+  if (identityCategories.includes(type)) {
+    return idCredentialTypes;
+  }
+  if (ServiceTypesOfServiceCategory[ServiceCategories.Issuer].includes(type)) {
+    return difference(registeredCredentialTypes, idCredentialTypes);
+  }
+  return undefined;
+};
+
+module.exports = {
+  validateServiceCredentialType,
+};

package/src/entities/organization-services/domains/validate-service-endpoint.js

@@ -0,0 +1,35 @@
+const newError = require('http-errors');
+const { isEmpty } = require('lodash/fp');
+const { isDidUrlWithFragment } = require('@verii/did-doc');
+const { isIssuingOrInspectionService } = require('./is-service-category');
+
+const validateServiceEndpoint = (
+  service,
+  issuingAndInspectionRequiresCaoServiceRef = false
+) => {
+  if (isEmpty(service.serviceEndpoint)) {
+    throw newError(400, 'Service must have a serviceEndpoint', {
+      errorCode: 'service_endpoint_required',
+    });
+  }
+
+  if (isIssuingOrInspectionService(service)) {
+    if (isDidUrlWithFragment(service.serviceEndpoint)) {
+      return;
+    }
+    if (issuingAndInspectionRequiresCaoServiceRef) {
+      throw newError(400, 'serviceEndpoint must be a did service reference', {
+        errorCode: 'service_endpoint_must_be_ref',
+      });
+    }
+  }
+
+  const url = new URL(service.serviceEndpoint);
+  if (url.protocol !== 'https:') {
+    throw newError(400, 'serviceEndpoint is invalid format', {
+      errorCode: 'service_endpoint_invalid',
+    });
+  }
+};
+
+module.exports = { validateServiceEndpoint };

package/src/entities/organization-services/domains/validate-service-fields-by-service-type.js

@@ -0,0 +1,37 @@
+const newError = require('http-errors');
+const { ServiceTypes } = require('@verii/organizations-registry');
+
+const buildMessage = (serviceType, fieldName) =>
+  `${serviceType} service type requires "${fieldName}"`;
+
+const serviceTypeToRequiredFieldsMap = {
+  [ServiceTypes.HolderAppProviderType]: [
+    'playStoreUrl',
+    'appleAppStoreUrl',
+    'appleAppId',
+    'googlePlayId',
+    'logoUrl',
+    'name',
+    'supportedExchangeProtocols',
+  ],
+  [ServiceTypes.WebWalletProviderType]: [
+    'logoUrl',
+    'name',
+    'supportedExchangeProtocols',
+  ],
+};
+
+const validateServiceFieldsByServiceType = (service = {}) => {
+  if (!serviceTypeToRequiredFieldsMap[service.type]) {
+    return;
+  }
+  for (const requiredField of serviceTypeToRequiredFieldsMap[service.type]) {
+    if (!service[requiredField]) {
+      throw newError(400, buildMessage(service.type, requiredField));
+    }
+  }
+};
+
+module.exports = {
+  validateServiceFieldsByServiceType,
+};

package/src/entities/organization-services/domains/validate-service-id-uniqueness.js

@@ -0,0 +1,19 @@
+const newError = require('http-errors');
+const { find } = require('lodash/fp');
+const {
+  OrganizationRegistryErrorMessages,
+} = require('@verii/organizations-registry');
+
+const validateServiceIdUniqueness = (newService, existingServices = []) => {
+  const matchingService = find({ id: newService.id }, existingServices);
+
+  if (matchingService != null) {
+    throw newError.BadRequest(
+      OrganizationRegistryErrorMessages.SERVICE_ID_ALREADY_EXISTS
+    );
+  }
+};
+
+module.exports = {
+  validateServiceIdUniqueness,
+};

package/src/entities/organization-services/domains/validate-service-key-purposes.js

@@ -0,0 +1,56 @@
+const newError = require('http-errors');
+const { includes, map, find, flow, compact } = require('lodash/fp');
+const { KeyPurposes } = require('@verii/crypto');
+const { ServiceTypes } = require('@verii/organizations-registry');
+
+const validateServiceKeyPurposes = (registeredService, keys) => {
+  const requiredPurposes = requiredKeyPurposes[registeredService.type];
+
+  // gets a single key for each required purpose
+  const registeredKeys = flow(
+    map(findKeyWithRequiredPurpose(keys)),
+    compact
+  )(requiredPurposes);
+
+  // if the number of found keys doesnt equal the number required, then its an error
+  if (registeredKeys.length !== requiredPurposes.length) {
+    throw newError(400, 'No required purpose for service', {
+      code: 'required_key_missing_in_byo_did_doc',
+    });
+  }
+};
+
+const findKeyWithRequiredPurpose = (keys) => (requiredPurpose) =>
+  find((key) => includes(requiredPurpose, key.purposes), keys);
+
+const keyPurposesCaoNode = [KeyPurposes.DLT_TRANSACTIONS];
+const keyPurposesIssuing = [
+  KeyPurposes.DLT_TRANSACTIONS,
+  KeyPurposes.ISSUING_METADATA,
+  KeyPurposes.EXCHANGES,
+];
+const keyPurposesRelyingParties = [
+  KeyPurposes.DLT_TRANSACTIONS,
+  KeyPurposes.EXCHANGES,
+];
+
+const requiredKeyPurposes = {
+  // CAO and NODE
+  [ServiceTypes.CredentialAgentOperatorType]: keyPurposesCaoNode,
+  [ServiceTypes.NodeOperatorType]: keyPurposesCaoNode,
+  // ISSUING
+  [ServiceTypes.IdentityIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.CareerIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.NotaryIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.ContactIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.NotaryContactIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.NotaryIdDocumentIssuerType]: keyPurposesIssuing,
+  [ServiceTypes.IdDocumentIssuerType]: keyPurposesIssuing,
+  // RELYING PARTIES
+  [ServiceTypes.HolderAppProviderType]: keyPurposesRelyingParties,
+  [ServiceTypes.InspectionType]: keyPurposesRelyingParties,
+};
+
+module.exports = {
+  validateServiceKeyPurposes,
+};

package/src/entities/organization-services/domains/validate-service-type.js

@@ -0,0 +1,12 @@
+const { isEmpty } = require('lodash/fp');
+const newError = require('http-errors');
+
+const validateServiceType = (service) => {
+  if (isEmpty(service.type)) {
+    throw newError(400, 'Service must have a type', {
+      errorCode: 'type_required',
+    });
+  }
+};
+
+module.exports = { validateServiceType };

package/src/entities/organization-services/domains/validate-service.js

@@ -0,0 +1,80 @@
+const { forEach } = require('lodash/fp');
+const { serviceExists } = require('@verii/did-doc');
+const newError = require('http-errors');
+const { validateServiceType } = require('./validate-service-type');
+const { validateServiceEndpoint } = require('./validate-service-endpoint');
+const {
+  validateServiceCredentialType,
+} = require('./validate-service-credential-type');
+const {
+  validateServiceFieldsByServiceType,
+} = require('./validate-service-fields-by-service-type');
+const { validateCaoServiceRefs } = require('./validate-cao-service-refs');
+const {
+  validateServiceKeyPurposes,
+} = require('./validate-service-key-purposes');
+const {
+  validateServiceIdUniqueness,
+} = require('./validate-service-id-uniqueness');
+
+const validateService = (service, caoServiceRefs, context) => {
+  validateServiceType(service);
+  validateServiceEndpoint(service);
+  validateServiceCredentialType(service, context);
+  validateServiceFieldsByServiceType(service);
+  validateCaoServiceRefs(service, caoServiceRefs);
+};
+
+const validateServices = (services, caoServiceRefs, context) => {
+  forEach(
+    (service) => validateService(service, caoServiceRefs, context),
+    services
+  );
+};
+
+const validateAdditionalService = (
+  service,
+  existingServices,
+  caoServiceRefs,
+  context
+) => {
+  validateService(service, caoServiceRefs, context);
+  validateServiceIdUniqueness(service, existingServices);
+};
+
+const validateInviteeService = (service, caoServiceRefs, context) => {
+  try {
+    validateServiceType(service);
+    validateServiceEndpoint(service, true);
+    validateServiceCredentialType(service, context);
+    validateCaoServiceRefs(service, caoServiceRefs);
+  } catch (error) {
+    if (error.errorCode == null) {
+      // eslint-disable-next-line better-mutation/no-mutation
+      error.errorCode = 'invitee_service_invalid';
+    }
+    throw error;
+  }
+};
+
+const validateByoDidDocService = (didDoc, serviceId, keys) => {
+  const didDocService = serviceExists(didDoc, serviceId);
+  if (didDocService == null) {
+    throw newError.BadRequest(`Service with ID ${serviceId} does not exist`, {
+      didDoc,
+      serviceId,
+    });
+  }
+  validateServiceType(didDocService);
+  validateServiceEndpoint(didDocService);
+  validateServiceKeyPurposes(didDocService, keys);
+  return didDocService;
+};
+
+module.exports = {
+  validateAdditionalService,
+  validateService,
+  validateServices,
+  validateInviteeService,
+  validateByoDidDocService,
+};