@cheqd/studio 3.16.0-develop.8 → 3.16.0

package/dist/controllers/api/accreditation.js

@@ -5,40 +5,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { StatusCodes } from 'http-status-codes';
-import { v4 } from 'uuid';
-import { AccreditationRequestType, DIDAccreditationPolicyTypes, DIDAccreditationTypes, } from '../../types/accreditation.js';
-import { CredentialCategory, CredentialConnectors } from '../../types/credential.js';
+import { AccreditationRequestType } from '../../types/accreditation.js';
 import { OperationCategoryNameEnum, OperationNameEnum } from '../../types/constants.js';
-import { IdentityServiceStrategySetup } from '../../services/identity/index.js';
 import { AccreditationService } from '../../services/api/accreditation.js';
-import { Credentials } from '../../services/api/credentials.js';
 import { eventTracker } from '../../services/track/tracker.js';
 import { body, query } from '../validator/index.js';
 import { validate } from '../validator/decorator.js';
 import { constructDidUrl, parseDidFromDidUrl } from '../../helpers/helpers.js';
-import NodeCache from 'node-cache';
-import { StatusListType } from '../../types/credential-status.js';
 import { CheqdNetwork } from '@cheqd/sdk';
-const ACCREDITATION_RESOLVE_CACHE_TTL_MS = 30_000;
-const ACCREDITATION_RESOLVE_CACHE_MAX_ENTRIES = 200;
-const ACCREDITATION_RESOLVE_CONCURRENCY = 8;
-function buildCacheKey(url, customerId) {
-    return `${customerId ?? 'anonymous'}::${url}`;
-}
-const accreditationResolveCache = new NodeCache({
-    stdTTL: ACCREDITATION_RESOLVE_CACHE_TTL_MS / 1000,
-    checkperiod: 0,
-    useClones: false,
-    deleteOnExpire: true,
-    maxKeys: ACCREDITATION_RESOLVE_CACHE_MAX_ENTRIES,
-});
-const inFlightAccreditations = new Map();
-function getCachedAccreditation(key) {
-    return accreditationResolveCache.get(key) ?? null;
-}
-function setCachedAccreditation(key, value) {
-    accreditationResolveCache.set(key, value);
-}
 export class AccreditationController {
     static issueValidator = [
         query('accreditationType')
@@ -188,10 +162,8 @@ export class AccreditationController {
      *         $ref: '#/components/schemas/InternalError'
      */
     async issue(request, response) {
-        // Get strategy e.g. postgres or local
-        const identityServiceStrategySetup = new IdentityServiceStrategySetup();
-        // Extract did from params
         const { accreditationType } = request.query;
+        const { schemas, issuerDid, subjectDid } = request.body;
         // Handles string input instead of an array
         if (typeof request.body.type === 'string') {
             request.body.type = [request.body.type];
@@ -199,117 +171,27 @@ export class AccreditationController {
         if (typeof request.body['@context'] === 'string') {
             request.body['@context'] = [request.body['@context']];
         }
-        const { issuerDid, subjectDid, schemas, type, parentAccreditation, rootAuthorization, trustFramework, trustFrameworkId, attributes, accreditationName, format, credentialStatus, } = request.body;
         try {
-            // Validate issuer and subject DIDs in parallel only for authorize
-            // For attest, accredit they are validated in verify_accreditation
-            const [body, subjectDidRes] = await Promise.all([
-                identityServiceStrategySetup.agent.resolveDid(issuerDid),
-                identityServiceStrategySetup.agent.resolveDid(subjectDid),
-            ]);
-            // Validate issuer DID
-            if (!body?.didDocument) {
-                return response.status(StatusCodes.BAD_REQUEST).send({
-                    error: `DID ${issuerDid} is not resolved because of error from resolver: ${body.didResolutionMetadata.error}.`,
-                });
-            }
-            if (body.didDocumentMetadata.deactivated) {
-                return response.status(StatusCodes.BAD_REQUEST).send({
-                    error: `${issuerDid} is deactivated`,
-                });
-            }
-            // Validate subject DID
-            if (!subjectDidRes?.didDocument) {
-                return response.status(StatusCodes.BAD_REQUEST).send({
-                    error: `DID ${subjectDid} is not resolved because of error from resolver: ${body.didResolutionMetadata.error}.`,
-                });
+            const result = await AccreditationService.instance.issue_accreditation(accreditationType, issuerDid, subjectDid, schemas, request.body, response.locals.customer);
+            if (result.success) {
+                // Track operation
+                const trackInfo = {
+                    category: OperationCategoryNameEnum.CREDENTIAL,
+                    name: OperationNameEnum.CREDENTIAL_ISSUE,
+                    customer: response.locals.customer,
+                    user: response.locals.user,
+                    data: {
+                        did: issuerDid,
+                    },
+                };
+                eventTracker.emit('track', trackInfo);
+                return response.status(StatusCodes.OK).json(result.data);
             }
-            if (subjectDidRes.didDocumentMetadata.deactivated) {
-                return response.status(StatusCodes.BAD_REQUEST).send({
-                    error: `${subjectDid} is deactivated`,
+            else {
+                return response.status(result.status).json({
+                    error: result.error,
                 });
             }
-            const resourceId = v4();
-            const accreditedFor = schemas.map(({ url, types }) => ({
-                schemaId: url,
-                types: Array.isArray(types) ? types : [types],
-            }));
-            // construct credential request
-            const credentialRequest = {
-                subjectDid,
-                attributes: {
-                    ...attributes,
-                    accreditedFor,
-                    id: subjectDid,
-                },
-                issuerDid,
-                format: format || 'jwt',
-                connector: CredentialConnectors.Resource, // resource connector
-                credentialId: resourceId,
-                credentialName: accreditationName,
-                credentialStatus,
-                category: CredentialCategory.ACCREDITATION,
-            };
-            let resourceType;
-            switch (accreditationType) {
-                case AccreditationRequestType.authorize:
-                    resourceType = DIDAccreditationTypes.VerifiableAuthorizationForTrustChain;
-                    credentialRequest.type = [...(type || []), resourceType];
-                    credentialRequest.termsOfUse = {
-                        type: DIDAccreditationPolicyTypes.Authorize,
-                        trustFramework,
-                        trustFrameworkId,
-                    };
-                    break;
-                case AccreditationRequestType.accredit:
-                    resourceType = DIDAccreditationTypes.VerifiableAccreditationToAccredit;
-                    credentialRequest.type = [...(type || []), resourceType];
-                    credentialRequest.termsOfUse = {
-                        type: DIDAccreditationPolicyTypes.Accredit,
-                        parentAccreditation,
-                        rootAuthorization,
-                    };
-                    break;
-                case AccreditationRequestType.attest:
-                    resourceType = DIDAccreditationTypes.VerifiableAccreditationToAttest;
-                    credentialRequest.type = [...(type || []), resourceType];
-                    credentialRequest.termsOfUse = {
-                        type: DIDAccreditationPolicyTypes.Accredit,
-                        parentAccreditation,
-                        rootAuthorization,
-                    };
-                    break;
-            }
-            // validate parent and root accreditations
-            if (accreditationType === AccreditationRequestType.accredit ||
-                accreditationType === AccreditationRequestType.attest) {
-                const result = await AccreditationService.instance.verify_accreditation(issuerDid, parentAccreditation, accreditedFor, true, false, response.locals.customer, rootAuthorization);
-                if (result.success === false) {
-                    return response.status(result.status).send({
-                        error: `Invalid Request: Root Authorization or parent Accreditation is not valid: ${result.error}`,
-                    });
-                }
-            }
-            // issue accreditation
-            const accreditation = await Credentials.instance.issue_credential(credentialRequest, response.locals.customer);
-            // Track operation
-            const trackInfo = {
-                category: OperationCategoryNameEnum.CREDENTIAL,
-                name: OperationNameEnum.CREDENTIAL_ISSUE,
-                customer: response.locals.customer,
-                user: response.locals.user,
-                data: {
-                    did: issuerDid,
-                },
-            };
-            eventTracker.emit('track', trackInfo);
-            return response.status(StatusCodes.OK).json({
-                didUrls: [
-                    `${issuerDid}/resources/${resourceId}`,
-                    `${issuerDid}?resourceName=${encodeURIComponent(accreditationName)}&resourceType=${credentialRequest.type}`,
-                ],
-                accreditation,
-            });
         }
         catch (error) {
             return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
@@ -362,7 +244,6 @@ export class AccreditationController {
      *         $ref: '#/components/schemas/InternalError'
      */
     async verify(request, response) {
-        // Extract did from params
         let { verifyStatus = false, allowDeactivatedDid = false } = request.query;
         const { policies, subjectDid, schemas } = request.body;
         // construct didUrl
@@ -442,12 +323,8 @@ export class AccreditationController {
      *         $ref: '#/components/schemas/InternalError'
      */
     async revoke(request, response) {
-        // Get publish flag
         const { publish } = request.query;
-        // Get symmetric key
         const { symmetricKey, ...didUrlParams } = request.body;
-        // Get strategy e.g. postgres or local
-        const identityServiceStrategySetup = new IdentityServiceStrategySetup(response.locals.customer.customerId);
         const didUrl = constructDidUrl(didUrlParams);
         if (!didUrl) {
             return response.status(StatusCodes.BAD_REQUEST).json({
@@ -455,41 +332,36 @@ export class AccreditationController {
             });
         }
         try {
-            const res = await identityServiceStrategySetup.agent.resolve(didUrl);
-            const resource = await res.json();
-            if (resource.dereferencingMetadata) {
-                return response.status(StatusCodes.NOT_FOUND).json({
-                    error: `DID URL ${didUrl} is not found`,
-                });
+            const result = await AccreditationService.instance.revoke_accreditation(didUrl, publish, symmetricKey, response.locals.customer);
+            if (result.success) {
+                // Track operation if revocation was successful and publish is true
+                // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
+                // and it will be tracked there
+                if (result.data.resourceMetadata && publish) {
+                    // get issuer did
+                    const issuerDid = parseDidFromDidUrl(didUrl);
+                    const trackInfo = {
+                        category: OperationCategoryNameEnum.CREDENTIAL,
+                        name: OperationNameEnum.CREDENTIAL_REVOKE,
+                        customer: response.locals.customer,
+                        user: response.locals.user,
+                        data: {
+                            did: issuerDid,
+                            encrypted: result.data.statusList?.metadata?.encrypted,
+                            resource: result.data.resourceMetadata,
+                            symmetricKey: '',
+                        },
+                    };
+                    // Track operation
+                    eventTracker.emit('track', trackInfo);
+                }
+                return response.status(StatusCodes.OK).json(result.data);
             }
-            const accreditation = resource;
-            const result = await identityServiceStrategySetup.agent.revokeCredentials(accreditation, StatusListType.Bitstring, // default to BitstringStatusList for accreditation
-            publish, response.locals.customer, symmetricKey);
-            // Track operation if revocation was successful and publish is true
-            // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
-            // and it will be tracked there
-            if (!result.error && result.resourceMetadata && publish) {
-                // get issuer did
-                const issuerDid = typeof accreditation.issuer === 'string'
-                    ? accreditation.issuer
-                    : accreditation.issuer.id;
-                const trackInfo = {
-                    category: OperationCategoryNameEnum.CREDENTIAL,
-                    name: OperationNameEnum.CREDENTIAL_REVOKE,
-                    customer: response.locals.customer,
-                    user: response.locals.user,
-                    data: {
-                        did: issuerDid,
-                        encrypted: result.statusList?.metadata?.encrypted,
-                        resource: result.resourceMetadata,
-                        symmetricKey: '',
-                    },
-                };
-                // Track operation
-                eventTracker.emit('track', trackInfo);
+            else {
+                return response.status(result.status).json({
+                    error: result.error,
+                });
             }
-            // Return Ok response
-            return response.status(StatusCodes.OK).json(result);
         }
         catch (error) {
             return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
@@ -537,12 +409,8 @@ export class AccreditationController {
      *         $ref: '#/components/schemas/InternalError'
      */
     async suspend(request, response) {
-        // Get publish flag
         const { publish } = request.query;
-        // Get symmetric key
         const { symmetricKey, ...didUrlParams } = request.body;
-        // Get strategy e.g. postgres or local
-        const identityServiceStrategySetup = new IdentityServiceStrategySetup(response.locals.customer.customerId);
         const didUrl = constructDidUrl(didUrlParams);
         if (!didUrl) {
             return response.status(StatusCodes.BAD_REQUEST).json({
@@ -550,43 +418,36 @@ export class AccreditationController {
             });
         }
         try {
-            const res = await identityServiceStrategySetup.agent.resolve(didUrl);
-            const resource = await res.json();
-            if (resource.dereferencingMetadata) {
-                return {
-                    success: false,
-                    status: 404,
-                    error: `DID URL ${didUrl} is not found`,
-                };
+            const result = await AccreditationService.instance.suspend_accreditation(didUrl, publish, symmetricKey, response.locals.customer);
+            if (result.success) {
+                // Track operation if suspension was successful and publish is true
+                // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
+                // and it will be tracked there
+                if (result.data.resourceMetadata && publish) {
+                    // get issuer did
+                    const issuerDid = parseDidFromDidUrl(didUrl);
+                    const trackInfo = {
+                        category: OperationCategoryNameEnum.CREDENTIAL,
+                        name: OperationNameEnum.CREDENTIAL_SUSPEND,
+                        customer: response.locals.customer,
+                        user: response.locals.user,
+                        data: {
+                            did: issuerDid,
+                            encrypted: result.data.statusList?.metadata?.encrypted,
+                            resource: result.data.resourceMetadata,
+                            symmetricKey: '',
+                        },
+                    };
+                    // Track operation
+                    eventTracker.emit('track', trackInfo);
+                }
+                return response.status(StatusCodes.OK).json(result.data);
             }
-            const accreditation = resource;
-            const result = await identityServiceStrategySetup.agent.suspendCredentials(accreditation, StatusListType.Bitstring, // default to BitstringStatusList for accreditation
-            publish, response.locals.customer, symmetricKey);
-            // Track operation if revocation was successful and publish is true
-            // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
-            // and it will be tracked there
-            if (!result.error && result.resourceMetadata && publish) {
-                // get issuer did
-                const issuerDid = typeof accreditation.issuer === 'string'
-                    ? accreditation.issuer
-                    : accreditation.issuer.id;
-                const trackInfo = {
-                    category: OperationCategoryNameEnum.CREDENTIAL,
-                    name: OperationNameEnum.CREDENTIAL_SUSPEND,
-                    customer: response.locals.customer,
-                    user: response.locals.user,
-                    data: {
-                        did: issuerDid,
-                        encrypted: result.statusList?.metadata?.encrypted,
-                        resource: result.resourceMetadata,
-                        symmetricKey: '',
-                    },
-                };
-                // Track operation
-                eventTracker.emit('track', trackInfo);
+            else {
+                return response.status(result.status).json({
+                    error: result.error,
+                });
             }
-            // Return Ok response
-            return response.status(StatusCodes.OK).json(result);
         }
         catch (error) {
             return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
@@ -634,12 +495,8 @@ export class AccreditationController {
      *         $ref: '#/components/schemas/InternalError'
      */
     async reinstate(request, response) {
-        // Get publish flag
         const { publish } = request.query;
-        // Get symmetric key
         const { symmetricKey, ...didUrlParams } = request.body;
-        // Get strategy e.g. postgres or local
-        const identityServiceStrategySetup = new IdentityServiceStrategySetup(response.locals.customer.customerId);
         const didUrl = constructDidUrl(didUrlParams);
         if (!didUrl) {
             return response.status(StatusCodes.BAD_REQUEST).json({
@@ -647,43 +504,36 @@ export class AccreditationController {
             });
         }
         try {
-            const res = await identityServiceStrategySetup.agent.resolve(didUrl);
-            const resource = await res.json();
-            if (resource.dereferencingMetadata) {
-                return {
-                    success: false,
-                    status: 404,
-                    error: `DID URL ${didUrl} is not found`,
-                };
+            const result = await AccreditationService.instance.reinstate_accreditation(didUrl, publish, symmetricKey, response.locals.customer);
+            if (result.success) {
+                // Track operation if reinstatement was successful and publish is true
+                // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
+                // and it will be tracked there
+                if (result.data.resourceMetadata && publish) {
+                    // get issuer did
+                    const issuerDid = parseDidFromDidUrl(didUrl);
+                    const trackInfo = {
+                        category: OperationCategoryNameEnum.CREDENTIAL,
+                        name: OperationNameEnum.CREDENTIAL_UNSUSPEND,
+                        customer: response.locals.customer,
+                        user: response.locals.user,
+                        data: {
+                            did: issuerDid,
+                            encrypted: result.data.statusList?.metadata?.encrypted || false,
+                            resource: result.data.resourceMetadata,
+                            symmetricKey: '',
+                        },
+                    };
+                    // Track operation
+                    eventTracker.emit('track', trackInfo);
+                }
+                return response.status(StatusCodes.OK).json(result.data);
             }
-            const accreditation = resource;
-            const result = await identityServiceStrategySetup.agent.reinstateCredentials(accreditation, StatusListType.Bitstring, // default to BitstringStatusList for accreditation
-            publish, response.locals.customer, symmetricKey);
-            // Track operation if revocation was successful and publish is true
-            // Otherwise the StatusList2021 or BitstringStatusList publisher should manually publish the resource
-            // and it will be tracked there
-            if (!result.error && result.resourceMetadata && publish) {
-                // get issuer did
-                const issuerDid = typeof accreditation.issuer === 'string'
-                    ? accreditation.issuer
-                    : accreditation.issuer.id;
-                const trackInfo = {
-                    category: OperationCategoryNameEnum.CREDENTIAL,
-                    name: OperationNameEnum.CREDENTIAL_UNSUSPEND,
-                    customer: response.locals.customer,
-                    user: response.locals.user,
-                    data: {
-                        did: issuerDid,
-                        encrypted: result.statusList?.metadata?.encrypted || false,
-                        resource: result.resourceMetadata,
-                        symmetricKey: '',
-                    },
-                };
-                // Track operation
-                eventTracker.emit('track', trackInfo);
+            else {
+                return response.status(result.status).json({
+                    error: result.error,
+                });
             }
-            // Return Ok response
-            return response.status(StatusCodes.OK).json(result);
         }
         catch (error) {
             return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
@@ -754,125 +604,16 @@ export class AccreditationController {
      */
     async listAccreditations(request, response) {
         const { network, accreditationType, did, page, limit } = request.query;
-        // Get strategy e.g. postgres or local
-        const identityServiceStrategySetup = response.locals.customer
-            ? new IdentityServiceStrategySetup(response.locals.customer.customerId)
-            : new IdentityServiceStrategySetup();
-        let resourceType;
-        switch (accreditationType) {
-            case AccreditationRequestType.authorize:
-                resourceType = DIDAccreditationTypes.VerifiableAuthorizationForTrustChain;
-                break;
-            case AccreditationRequestType.accredit:
-                resourceType = DIDAccreditationTypes.VerifiableAccreditationToAccredit;
-                break;
-            case AccreditationRequestType.attest:
-                resourceType = DIDAccreditationTypes.VerifiableAccreditationToAttest;
-                break;
-            default:
-                return response.status(StatusCodes.BAD_REQUEST).json({
-                    error: `Invalid accreditationType: ${accreditationType}. Must be one of: authorize, accredit, attest.`,
-                });
-        }
         try {
-            // Fetch resources of accreditation resourceType associated with the account
-            const { resources } = await identityServiceStrategySetup.agent.findLatestResourcesVersionsByType(resourceType, response.locals.customer, network, did, page, limit);
-            // Build resource URLs for resolution
-            const resourceUrls = resources.map((item) => `${item.did}/resources/${item.resourceId}`);
-            // No resources to resolve, return early
-            if (resourceUrls.length === 0) {
-                return response.status(StatusCodes.OK).json({
-                    total: 0,
-                    accreditations: [],
-                });
+            const result = await AccreditationService.instance.list_accreditations(response.locals.customer, accreditationType, network, did, page, limit);
+            if (result.success) {
+                return response.status(StatusCodes.OK).json(result.data);
             }
-            // 1. Fetch all tracking records from the issued credentials table
-            const { credentials: trackingRecords } = await Credentials.instance.list(response.locals.customer, {
-                category: CredentialCategory.ACCREDITATION,
-                providerCredentialId: resources.map((item) => item.resourceId),
-                credentialType: resourceType,
-            });
-            // 2. OPTIMIZATION: Create a Map for O(1) tracking record lookup by providerCredentialId
-            const trackingMap = new Map();
-            for (const record of trackingRecords) {
-                trackingMap.set(record.providerCredentialId, record);
+            else {
+                return response.status(result.status).json({
+                    error: result.error,
+                });
             }
-            const resolveAccreditationWithCache = async (url) => {
-                const cacheKey = buildCacheKey(url, response.locals.customer?.customerId);
-                const cached = getCachedAccreditation(cacheKey);
-                if (cached) {
-                    return cached;
-                }
-                const inFlight = inFlightAccreditations.get(cacheKey);
-                if (inFlight) {
-                    return inFlight;
-                }
-                const resolverPromise = (async () => {
-                    try {
-                        const res = await identityServiceStrategySetup.agent.resolve(url, true);
-                        const credential = await res.json();
-                        // Skip if the credential doesn't have contentStream
-                        if (!credential.contentStream) {
-                            return null;
-                        }
-                        const resourceId = credential.contentMetadata.resourceId;
-                        const trackingRecord = trackingMap.get(resourceId);
-                        if (trackingRecord) {
-                            const { issuedCredentialId, providerId, providerCredentialId, status, statusUpdatedAt } = trackingRecord;
-                            // Merge tracking metadata with credential
-                            const accreditation = {
-                                ...credential.contentStream,
-                                metadata: {
-                                    issuedCredentialId,
-                                    providerId,
-                                    providerCredentialId,
-                                    status,
-                                    statusUpdatedAt,
-                                },
-                            };
-                            setCachedAccreditation(cacheKey, accreditation);
-                            return accreditation;
-                        }
-                        else {
-                            // No tracking record, return just the credential (legacy)
-                            setCachedAccreditation(cacheKey, credential.contentStream);
-                            return credential.contentStream;
-                        }
-                    }
-                    catch (error) {
-                        console.error(`Failed to process accreditation for URL: ${url}`, error);
-                        return null;
-                    }
-                    finally {
-                        inFlightAccreditations.delete(cacheKey);
-                    }
-                })();
-                inFlightAccreditations.set(cacheKey, resolverPromise);
-                return resolverPromise;
-            };
-            // 3. Resolve resources and enhance with tracking metadata with bounded concurrency
-            const resolvedAccreditations = new Array(resourceUrls.length);
-            let currentIndex = 0;
-            const workers = Array.from({ length: Math.min(ACCREDITATION_RESOLVE_CONCURRENCY, resourceUrls.length) }, async () => {
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    const index = currentIndex++;
-                    if (index >= resourceUrls.length) {
-                        break;
-                    }
-                    const accreditation = await resolveAccreditationWithCache(resourceUrls[index]);
-                    if (accreditation) {
-                        resolvedAccreditations[index] = accreditation;
-                    }
-                }
-            });
-            // 4. Wait for all resolutions to complete and filter out any failed/skipped ones (null)
-            await Promise.all(workers);
-            const accreditations = resolvedAccreditations.filter(Boolean);
-            return response.status(StatusCodes.OK).json({
-                total: accreditations.length,
-                accreditations: accreditations,
-            });
         }
         catch (error) {
             return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({