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

package/src/entities/organizations/repos/search-by-aggregation-extension.js

@@ -0,0 +1,128 @@
+const { omit, partition, isNumber, reduce } = require('lodash/fp');
+const {
+  ServiceCategories,
+  ServiceTypesOfServiceCategory,
+} = require('@verii/organizations-registry');
+const {
+  DEFAULT_SIZE,
+  DEFAULT_SKIP,
+  transformToSortDocument,
+} = require('@verii/rest-queries');
+
+const {
+  getServiceTypesFromCategories,
+} = require('../../organization-services/domains');
+
+const { transformDidFilter } = require('./transform-did-filter');
+
+const searchByAggregationExtension = (parent) => ({
+  searchByAggregation: (input) => {
+    const serviceTypes = getServiceTypesFromCategories(input);
+    const aggregationPipeline = [];
+
+    const matchStage = {
+      $match: {
+        activatedServiceIds: {
+          $exists: true,
+        },
+        deletedAt: { $exists: false },
+        ...transformIdFilter(input),
+      },
+    };
+
+    if (input.q) {
+      matchStage.$match['profile.name'] = {
+        $regex: new RegExp(input.q, 'igu'),
+      };
+    }
+    aggregationPipeline.push(matchStage);
+
+    if (serviceTypes) {
+      aggregationPipeline.push(buildServiceAggregationStage(serviceTypes));
+      aggregationPipeline.push({
+        $match: {
+          services: { $type: 'array', $ne: [] },
+        },
+      });
+    }
+
+    aggregationPipeline.push(buildSortStage(input));
+    aggregationPipeline.push(buildPageSkipStage(input));
+    aggregationPipeline.push(buildPageSizeStage(input));
+
+    return parent.collection().aggregate(aggregationPipeline).toArray();
+  },
+});
+const ISSUER_SERVICE_TYPES =
+  ServiceTypesOfServiceCategory[ServiceCategories.Issuer];
+
+const transformIdFilter = (input) =>
+  input?.filter?.did == null
+    ? {}
+    : transformDidFilter({
+        ...omit(['did'], input.filter),
+        'didDoc.id': { $in: input.filter.did },
+      });
+
+const buildServiceAggregationStage = (serviceTypes) => {
+  const [issuerServiceTypes, nonIssuerServiceTypes] = partition(
+    (s) => ISSUER_SERVICE_TYPES.includes(s),
+    serviceTypes
+  );
+
+  const projectStage = {
+    $project: {
+      didDoc: 1,
+      profile: 1,
+      activatedServiceIds: 1,
+      verifiableCredentialJwt: 1,
+      services: {
+        $filter: {
+          input: '$services',
+          as: 'itemService',
+          cond: {
+            $and: [
+              {
+                $in: [
+                  '$$itemService.type',
+                  [...issuerServiceTypes, ...nonIssuerServiceTypes],
+                ],
+              },
+              {
+                $in: ['$$itemService.id', '$activatedServiceIds'],
+              },
+            ],
+          },
+        },
+      },
+    },
+  };
+
+  return projectStage;
+};
+
+const buildSortStage = (input) => {
+  const $sort = reduce(
+    (acc, el) => ({ ...acc, ...{ [el[0]]: el[1] } }),
+    {},
+    transformToSortDocument(input)
+  );
+
+  return { $sort };
+};
+
+const buildPageSizeStage = ({ page }) => {
+  if (!isNumber(page?.size)) {
+    return { $limit: DEFAULT_SIZE };
+  }
+  return { $limit: page.size };
+};
+
+const buildPageSkipStage = ({ page } = {}) => {
+  if (!isNumber(page?.skip) || !isNumber(page?.size)) {
+    return { $skip: DEFAULT_SKIP * DEFAULT_SIZE };
+  }
+  return { $skip: page.skip * page.size };
+};
+
+module.exports = { searchByAggregationExtension };

package/src/entities/organizations/repos/transform-did-filter.js

@@ -0,0 +1,13 @@
+const { omit } = require('lodash/fp');
+
+const transformDidFilter = (filter) => {
+  const key = 'didDoc.id';
+  const val = filter[key];
+
+  return {
+    ...omit([key], filter),
+    $or: [{ [key]: val }, { 'didDoc.alsoKnownAs': val }],
+  };
+};
+
+module.exports = { transformDidFilter };

package/src/entities/organizations/repos/transform-organization-filter.js

@@ -0,0 +1,106 @@
+/*
+ * 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 { flow, isEmpty, omit, partition } = require('lodash/fp');
+const {
+  ServiceCategories,
+  ServiceTypesOfServiceCategory,
+} = require('@verii/organizations-registry');
+const { initTransformToFinder } = require('@verii/rest-queries');
+const { tableRegistry } = require('@spencejs/spence-mongo-repos');
+const {
+  getServiceTypesFromCategories,
+} = require('../../organization-services/domains');
+
+const ISSUER_SERVICE_TYPES =
+  ServiceTypesOfServiceCategory[ServiceCategories.Issuer];
+
+const transformServiceTypeFilter = (input) => {
+  const serviceTypes = getServiceTypesFromCategories(input);
+  return input?.filter?.serviceTypes == null
+    ? input
+    : {
+        ...input,
+        filter: {
+          ...omit(['serviceTypes', 'credentialTypes'], input.filter),
+          services: {
+            $elemMatch: buildRegistrarServiceElemMatch(input, serviceTypes),
+          },
+        },
+      };
+};
+
+const transformIdFilter = (input) =>
+  input?.filter?.did == null
+    ? input
+    : {
+        ...input,
+        filter: {
+          ...omit(['did'], input.filter),
+          'didDoc.id': { $in: input.filter.did },
+        },
+      };
+const buildRegistrarServiceElemMatch = (input, serviceTypes) => {
+  const [issuerServiceTypes, nonIssuerServiceTypes] = partition(
+    (s) => ISSUER_SERVICE_TYPES.includes(s),
+    serviceTypes
+  );
+
+  if (isEmpty(issuerServiceTypes)) {
+    return {
+      type: {
+        $in: nonIssuerServiceTypes,
+      },
+    };
+  }
+
+  if (isEmpty(input?.filter?.credentialTypes)) {
+    return {
+      type: {
+        $in: serviceTypes,
+      },
+    };
+  }
+
+  return {
+    $or: [
+      {
+        type: {
+          $in: issuerServiceTypes,
+        },
+        credentialTypes: {
+          $elemMatch: { $in: input.filter.credentialTypes },
+        },
+      },
+      {
+        type: {
+          $in: nonIssuerServiceTypes,
+        },
+      },
+    ],
+  };
+};
+
+const initTransformOrganizationFilter = () =>
+  initTransformToFinder(tableRegistry.organizations(), {
+    transformToFilterDocument: flow(
+      transformIdFilter,
+      transformServiceTypeFilter
+    ),
+  });
+
+module.exports = { initTransformOrganizationFilter };

package/src/entities/registrar-consents/constants.js

@@ -0,0 +1,10 @@
+const ConsentTypes = {
+  IssuerInspector: 'IssuerInspector',
+  CAO: 'CAO',
+  NodeOperator: 'NodeOperator',
+  RegistrarAppTerms: 'RegistrarAppTerms',
+  Signatory: 'Signatory',
+};
+module.exports = {
+  ConsentTypes,
+};

package/src/entities/registrar-consents/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('./registrar-consents-factory') };

package/src/entities/registrar-consents/factories/registrar-consents-factory.js

@@ -0,0 +1,38 @@
+/*
+ * 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 { register } = require('@spencejs/spence-factories');
+
+const { testRegistrarSuperUser } = require('@verii/tests-helpers');
+const consentsRepoPlugin = require('../repos/repo');
+const { ConsentTypes } = require('../../index');
+
+module.exports = (app) => {
+  return register(
+    'registrarConsent',
+    consentsRepoPlugin(app)({ config: app.config }),
+    async (overrides) => {
+      return {
+        userId: testRegistrarSuperUser.sub,
+        consentId: 'l-sJmvte2ku',
+        version: 1,
+        type: ConsentTypes.RegistrarAppTerms,
+        ...overrides(),
+      };
+    }
+  );
+};

package/src/entities/registrar-consents/index.js

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

package/src/entities/registrar-consents/repos/registrar-consent-repo-extension.js

@@ -0,0 +1,55 @@
+/**
+ * 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 { map } = require('lodash/fp');
+const { nanoid } = require('nanoid');
+
+const registrarConsentRepoExtension = (parent) => ({
+  registerConsent: (
+    { userId, organizationId, type, version, ...rest },
+    ...args
+  ) => {
+    return parent.insert(
+      {
+        consentId: nanoid(),
+        userId,
+        organizationId,
+        version,
+        type,
+        ...rest,
+      },
+      ...args
+    );
+  },
+  registerConsents: (consents, ...args) => {
+    const consentsForInsert = map((consent) => {
+      const { userId, organizationId, type, version, ...rest } = consent;
+      return {
+        consentId: nanoid(),
+        userId,
+        organizationId,
+        version,
+        type,
+        createdAt: new Date(),
+        ...rest,
+      };
+    }, consents);
+    return parent.insertMany(consentsForInsert, ...args);
+  },
+  extensions: parent.extensions.concat(['registrarConsentRepoExtension']),
+});
+
+module.exports = { registrarConsentRepoExtension };

package/src/entities/registrar-consents/repos/repo.js

@@ -0,0 +1,31 @@
+const {
+  repoFactory,
+  autoboxIdsExtension,
+} = require('@spencejs/spence-mongo-repos');
+const {
+  registrarConsentRepoExtension,
+} = require('./registrar-consent-repo-extension');
+
+module.exports = (app, options, next = () => {}) => {
+  next();
+  return repoFactory(
+    {
+      name: 'registrarConsents',
+      entityName: 'registrarConsents',
+      defaultProjection: {
+        _id: 1,
+        consentId: 1,
+        type: 1,
+        version: 1,
+        userId: 1,
+        organizationId: 1,
+        serviceId: 1,
+        createdAt: 1,
+      },
+      timestampKeys: { createdAt: 'createdAt', updatedAt: 'updatedAt' },
+      mutable: false,
+      extensions: [autoboxIdsExtension, registrarConsentRepoExtension],
+    },
+    app
+  );
+};

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

@@ -0,0 +1,12 @@
+const SignatoryEventStatus = {
+  APPROVED: 'APPROVED',
+  COMPLETED: 'COMPLETED',
+  REJECTED: 'REJECTED',
+  LINK_SENT: 'LINK_SENT',
+  MAX_REACHED: 'MAX_REACHED',
+  REMINDER_ERROR: 'REMINDER_ERROR',
+};
+
+module.exports = {
+  SignatoryEventStatus,
+};

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

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('./organization-emails'),
+  ...require('./constants'),
+};

package/src/entities/signatories/domain/organization-emails.js

@@ -0,0 +1,29 @@
+const titleMap = {
+  approve: 'Approval',
+  reject: 'Rejection',
+};
+
+const messageMap = {
+  approve: 'approved',
+  reject: 'rejected',
+};
+
+const signatoryApproveOrganizationEmail = (
+  {
+    organization: {
+      profile: { name, signatoryGivenName, signatoryFamilyName },
+    },
+    response,
+  },
+  { config }
+) => ({
+  subject: `${titleMap[response]} of registration by ${name}`,
+  // eslint-disable-next-line max-len
+  message: `${signatoryGivenName} ${signatoryFamilyName} ${messageMap[response]} the approval request of the registration of ${name} to the Velocity Network.`,
+  sender: config.noReplyEmail,
+  recipients: [config.registrarSupportEmail],
+});
+
+module.exports = {
+  signatoryApproveOrganizationEmail,
+};

package/src/entities/signatories/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('./signatory-status-factory') };

package/src/entities/signatories/factories/signatory-status-factory.js

@@ -0,0 +1,53 @@
+/*
+ * 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 { register } = require('@spencejs/spence-factories');
+
+const { ObjectId } = require('mongodb');
+const initOrganizationFactory = require('../../organizations/factories/organizations-factory');
+const { SignatoryEventStatus } = require('../../index');
+const signatoryStatusPlugin = require('../repos/repo');
+
+module.exports = (app) =>
+  register(
+    'signatoryStatus',
+    signatoryStatusPlugin(app)({ config: app.config }),
+    async (overrides, { getOrBuild }) => {
+      const organization = await getOrBuild(
+        'organization',
+        initOrganizationFactory(app)
+      );
+
+      return {
+        organizationDid: organization.didDoc.id,
+        organizationId: new ObjectId(organization._id),
+        events: [
+          {
+            state: SignatoryEventStatus.LINK_SENT,
+            timestamp: new Date(),
+          },
+        ],
+        authCodes: [
+          {
+            code: '12345',
+            timestamp: new Date(),
+          },
+        ],
+        ...overrides(),
+      };
+    }
+  );

package/src/entities/signatories/index.js

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

package/src/entities/signatories/orchestrators/approve-reminder.js

@@ -0,0 +1,24 @@
+const { SignatoryEventStatus } = require('../domain');
+const { ConsentTypes } = require('../../registrar-consents');
+
+const approveReminder = async (organization, req) => {
+  const { repos, config } = req;
+  const currentTime = new Date();
+  await repos.signatoryStatus.addState(
+    { organizationId: organization._id },
+    SignatoryEventStatus.APPROVED,
+    {
+      approvedAt: currentTime,
+    }
+  );
+  await repos.registrarConsents.registerConsent({
+    userId: organization.profile.signatoryEmail,
+    organizationId: organization._id,
+    type: ConsentTypes.Signatory,
+    version: config.signatoryConsentVersion,
+  });
+};
+
+module.exports = {
+  approveReminder,
+};

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

@@ -0,0 +1,6 @@
+module.exports = {
+  ...require('./send-reminders'),
+  ...require('./approve-reminder'),
+  ...require('./reject-reminder'),
+  ...require('./validate-auth-code'),
+};

package/src/entities/signatories/orchestrators/reject-reminder.js

@@ -0,0 +1,17 @@
+const { SignatoryEventStatus } = require('../domain');
+
+const rejectReminder = async (organization, req) => {
+  const { repos } = req;
+  const currentTime = new Date();
+  await repos.signatoryStatus.addState(
+    { organizationId: organization._id },
+    SignatoryEventStatus.REJECTED,
+    {
+      rejectedAt: currentTime,
+    }
+  );
+};
+
+module.exports = {
+  rejectReminder,
+};

package/src/entities/signatories/orchestrators/send-reminders.js

@@ -0,0 +1,102 @@
+const { isEmpty, size } = require('lodash/fp');
+const { nanoid } = require('nanoid');
+const { subMinutes } = require('date-fns/fp');
+const { SignatoryEventStatus } = require('../domain');
+
+const task = 'send-reminders';
+const sendReminders = async (
+  sendEmailToSignatoryForOrganizationApproval,
+  req
+) => {
+  const currentTime = new Date();
+  const { repos, config, log } = req;
+  const { signatoryLinkResend } = config;
+  const signatoryStatuses = await repos.signatoryStatus.findByEvent(
+    subMinutes(signatoryLinkResend, currentTime)
+  );
+  if (isEmpty(signatoryStatuses)) {
+    log.info({ task, message: 'No signatory reminders to send' });
+    return;
+  }
+
+  for await (const signatoryStatusDoc of signatoryStatuses) {
+    await sendReminder(
+      signatoryStatusDoc,
+      sendEmailToSignatoryForOrganizationApproval,
+      req
+    );
+  }
+};
+
+const sendReminder = async (
+  signatoryStatusDoc,
+  sendEmailToSignatoryForOrganizationApproval,
+  context
+) => {
+  const { repos, config, log } = context;
+  try {
+    const filter = { _id: signatoryStatusDoc.organizationId };
+    const organization = await repos.organizations.findOne({ filter });
+
+    if (isEmpty(organization)) {
+      log.error({ message: 'Organization not found', filter });
+      await repos.signatoryStatus.addState(
+        signatoryStatusDoc._id,
+        SignatoryEventStatus.REMINDER_ERROR,
+        {
+          error: 'Organization not found',
+        }
+      );
+      return;
+    }
+
+    if (size(signatoryStatusDoc.events) >= config.signatoryMaxReminderCount) {
+      await repos.signatoryStatus.addState(
+        signatoryStatusDoc._id,
+        SignatoryEventStatus.MAX_REACHED
+      );
+      await context.sendSupportEmail(
+        await context.renderTemplate(
+          'support-signatory-max-reminders-reached-email-subject',
+          { organization }
+        ),
+        await context.renderTemplate(
+          'support-signatory-max-reminders-reached-email-body',
+          {
+            organization,
+          }
+        )
+      );
+      return;
+    }
+
+    const authCode = nanoid();
+    await sendEmailToSignatoryForOrganizationApproval(
+      {
+        organization,
+        authCode,
+        isReminder: true,
+      },
+      context
+    );
+    await repos.signatoryStatus.addStateAndCode(
+      signatoryStatusDoc._id,
+      SignatoryEventStatus.LINK_SENT,
+      authCode
+    );
+  } catch (error) {
+    log.error({ err: error });
+    await repos.signatoryStatus.addState(
+      signatoryStatusDoc._id,
+      SignatoryEventStatus.REMINDER_ERROR,
+      {
+        error: error.message,
+      }
+    );
+  }
+};
+
+module.exports = {
+  sendReminders,
+  sendReminder,
+};