@cheqd/studio 3.12.1 → 3.13.0-develop.10

package/dist/controllers/api/providers.controller.d.ts

@@ -0,0 +1,214 @@
+import type { Request, Response } from 'express';
+export declare class ProvidersController {
+    static importDIDValidator: import("express-validator").ValidationChainWithExtensions<"isDID" | "isDIDArray" | "isDIDDocument" | "isVerificationMethod" | "isCreateDIDDocumentService" | "isService" | "isCheqdDidLinkedAlsoKnownAs" | "isKeyDID" | "isW3CCheqdCredential" | "isW3CCheqdCredentials" | "isW3CCheqdPresentation" | "isVeridaDID">[];
+    /**
+     * @openapi
+     * /providers:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get all available credential providers
+     *     description: Returns list of available credential providers
+     *     responses:
+     *       200:
+     *         description: Successful response
+     *         content:
+     *           application/json:
+     *             schema:
+     *               type: object
+     *               properties:
+     *                 providers:
+     *                   type: array
+     *                   items:
+     *                     type: object
+     */
+    getProviders(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/activated:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get customer's activated providers
+     *     description: Returns list of providers activated by the customer
+     *     responses:
+     *       200:
+     *         description: Successful response
+     */
+    getActiveProviders(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/{providerId}/configuration:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Provider configuration
+     */
+    getProviderConfiguration(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/{providerId}/activate:
+     *   post:
+     *     tags: [Providers]
+     *     summary: Activate a provider for the customer
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Provider activated successfully
+     *       400:
+     *         description: Invalid provider or already activated
+     *       404:
+     *         description: Provider not found
+     */
+    activateProvider(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/{providerId}/configuration:
+     *   put:
+     *     tags: [Providers]
+     *     summary: Update provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+     *               apiEndpoint:
+     *                 type: string
+     *                 format: uri
+     *                 description: API endpoint URL
+     *               webhookUrl:
+     *                 type: string
+     *                 format: uri
+     *                 description: Webhook URL for notifications
+     *               defaultSettings:
+     *                 type: object
+     *                 description: Provider-specific default settings
+     *     responses:
+     *       200:
+     *         description: Configuration updated successfully
+     *       400:
+     *         description: Invalid configuration data
+     *       404:
+     *         description: Provider configuration not found
+     */
+    updateProviderConfiguration(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/{providerId}/test:
+     *   post:
+     *     tags: [Providers]
+     *     summary: Test connection to a provider
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Connection test completed
+     *       400:
+     *         description: Connection test failed
+     *       404:
+     *         description: Provider configuration not found
+     */
+    testConnection(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     * /providers/{providerId}:
+     *   delete:
+     *     tags: [Providers]
+     *     summary: Remove provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Configuration removed successfully
+     */
+    removeProvider(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @openapi
+     *
+     * /providers/{providerId}/did/import:
+     *   post:
+     *     tags: [ Providers ]
+     *     summary: Import a DID into a Provider.
+     *     description: This endpoint imports a decentralized identifier associated with the user's account with the custodied keys into a provider.
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     requestBody:
+     *       content:
+     *         application/x-www-form-urlencoded:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - did
+     *             properties:
+     *               did:
+     *                 description: DID identifier to resolve.
+     *                 type: string
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - did
+     *             properties:
+     *               did:
+     *                 description: DID identifier to resolve.
+     *                 type: string
+     *     responses:
+     *       200:
+     *         description: The request was successful.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/DidResult'
+     *       400:
+     *         description: A problem with the input fields has occurred. Additional state information plus metadata may be available in the response body.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/InvalidRequest'
+     *             example:
+     *               error: InvalidRequest
+     *       401:
+     *         $ref: '#/components/schemas/UnauthorizedError'
+     *       500:
+     *         description: An internal error has occurred. Additional state information plus metadata may be available in the response body.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/InvalidRequest'
+     *             example:
+     *               error: Internal Error
+     */
+    importDid(request: Request, response: Response): Promise<Response<any, Record<string, any>>>;
+}
+//# sourceMappingURL=providers.controller.d.ts.map

package/dist/controllers/api/providers.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.controller.d.ts","sourceRoot":"","sources":["../../../src/controllers/api/providers.controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAajD,qBAAa,mBAAmB;IAC/B,OAAc,kBAAkB,yTAG9B;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACG,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IAW9C;;;;;;;;;;OAUG;IACG,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IA6BpD;;;;;;;;;;;;;;;OAeG;IACG,wBAAwB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IA2C1D;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IAgClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,2BAA2B,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IAyE7D;;;;;;;;;;;;;;;;;;;OAmBG;IACG,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IAsBhD;;;;;;;;;;;;;;;OAeG;IACG,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ;IAiBhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IAEU,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ;CA4C3D"}

package/dist/controllers/api/providers.controller.js

@@ -0,0 +1,462 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { StatusCodes } from 'http-status-codes';
+import { ProviderService } from '../../services/api/provider.service.js';
+import { validate } from '../validator/decorator.js';
+import { DockIdentityService } from '../../services/identity/providers/index.js';
+import { IdentityServiceStrategySetup } from '../../services/identity/index.js';
+import { OperationCategoryNameEnum, OperationNameEnum } from '../../types/constants.js';
+import { eventTracker } from '../../services/track/tracker.js';
+import { check, param } from '../validator/index.js';
+export class ProvidersController {
+    static importDIDValidator = [
+        check('did').exists().isDID().bail(),
+        param('providerId').exists().withMessage('providerId is required').isString().bail(),
+    ];
+    /**
+     * @openapi
+     * /providers:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get all available credential providers
+     *     description: Returns list of available credential providers
+     *     responses:
+     *       200:
+     *         description: Successful response
+     *         content:
+     *           application/json:
+     *             schema:
+     *               type: object
+     *               properties:
+     *                 providers:
+     *                   type: array
+     *                   items:
+     *                     type: object
+     */
+    async getProviders(req, res) {
+        try {
+            const providers = await ProviderService.instance.getAllProviders();
+            return res.status(StatusCodes.OK).json({ providers });
+        }
+        catch (error) {
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Internal error: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/activated:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get customer's activated providers
+     *     description: Returns list of providers activated by the customer
+     *     responses:
+     *       200:
+     *         description: Successful response
+     */
+    async getActiveProviders(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const configurations = await ProviderService.instance.getCustomerConfigurations(customer.customerId);
+            const configuredProviders = configurations.map((config) => ({
+                configId: config.configId,
+                providerId: config.providerId,
+                tenantId: config.tenantId,
+                providerName: config.provider.name,
+                providerType: config.provider.providerType,
+                apiEndpoint: config.apiEndpoint,
+                webhookUrl: config.webhookUrl,
+                validated: config.validated,
+                validatedAt: config.validatedAt,
+                active: config.active,
+                defaultSettings: config.defaultSettings,
+                createdAt: config.createdAt,
+                updatedAt: config.updatedAt,
+            }));
+            return res.status(StatusCodes.OK).json({ providers: configuredProviders });
+        }
+        catch (error) {
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Internal error: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/{providerId}/configuration:
+     *   get:
+     *     tags: [Providers]
+     *     summary: Get provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Provider configuration
+     */
+    async getProviderConfiguration(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const { providerId } = req.params;
+            const config = await ProviderService.instance.getProviderConfiguration(customer.customerId, providerId);
+            if (!config) {
+                return res.status(StatusCodes.NOT_FOUND).json({
+                    error: `No configuration found for provider ${providerId}`,
+                });
+            }
+            // Don't return encrypted API key
+            const safeConfig = {
+                configId: config.configId,
+                providerId: config.providerId,
+                tenantId: config.tenantId,
+                apiEndpoint: config.apiEndpoint,
+                webhookUrl: config.webhookUrl,
+                validated: config.validated,
+                validatedAt: config.validatedAt,
+                active: config.active,
+                defaultSettings: config.defaultSettings,
+                hasApiKey: !!config.encryptedApiKey,
+                provider: {
+                    name: config.provider.name,
+                    description: config.provider.description,
+                    providerType: config.provider.providerType,
+                    supportedFormats: config.provider.supportedFormats,
+                    supportedProtocols: config.provider.supportedProtocols,
+                    metadata: config.provider.metadata,
+                },
+            };
+            return res.status(StatusCodes.OK).json({ configuration: safeConfig });
+        }
+        catch (error) {
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Internal error: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/{providerId}/activate:
+     *   post:
+     *     tags: [Providers]
+     *     summary: Activate a provider for the customer
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Provider activated successfully
+     *       400:
+     *         description: Invalid provider or already activated
+     *       404:
+     *         description: Provider not found
+     */
+    async activateProvider(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const { providerId } = req.params;
+            const config = await ProviderService.instance.activateProvider(customer.customerId, providerId);
+            return res.status(StatusCodes.OK).json({
+                message: 'Provider activated successfully',
+                configuration: {
+                    configId: config.configId,
+                    providerId: config.providerId,
+                    tenantId: config.tenantId,
+                    providerName: config.provider.name,
+                    apiEndpoint: config.apiEndpoint,
+                    active: config.active,
+                    createdAt: config.createdAt,
+                },
+            });
+        }
+        catch (error) {
+            const status = error?.message.includes('not found')
+                ? StatusCodes.NOT_FOUND
+                : error?.message.includes('already activated')
+                    ? StatusCodes.CONFLICT
+                    : StatusCodes.BAD_REQUEST;
+            return res.status(status).json({
+                error: `Activation failed: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/{providerId}/configuration:
+     *   put:
+     *     tags: [Providers]
+     *     summary: Update provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+     *               apiEndpoint:
+     *                 type: string
+     *                 format: uri
+     *                 description: API endpoint URL
+     *               webhookUrl:
+     *                 type: string
+     *                 format: uri
+     *                 description: Webhook URL for notifications
+     *               defaultSettings:
+     *                 type: object
+     *                 description: Provider-specific default settings
+     *     responses:
+     *       200:
+     *         description: Configuration updated successfully
+     *       400:
+     *         description: Invalid configuration data
+     *       404:
+     *         description: Provider configuration not found
+     */
+    async updateProviderConfiguration(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const { providerId } = req.params;
+            const { apiEndpoint, webhookUrl, defaultSettings } = req.body;
+            // Validate input
+            if (apiEndpoint && typeof apiEndpoint !== 'string') {
+                return res.status(StatusCodes.BAD_REQUEST).json({
+                    error: 'Invalid API endpoint: must be a string',
+                });
+            }
+            if (webhookUrl && typeof webhookUrl !== 'string') {
+                return res.status(StatusCodes.BAD_REQUEST).json({
+                    error: 'Invalid webhook URL: must be a string',
+                });
+            }
+            if (process.env.APPLICATION_BASE_URL?.includes('localhost')) {
+                console.warn('Skipping URL validation in local development environment');
+            }
+            else {
+                if (apiEndpoint && !apiEndpoint.startsWith('https://')) {
+                    return res.status(StatusCodes.BAD_REQUEST).json({
+                        error: 'API endpoint must be a valid HTTPS URL',
+                    });
+                }
+                if (webhookUrl && webhookUrl.trim() && !webhookUrl.startsWith('https://')) {
+                    return res.status(StatusCodes.BAD_REQUEST).json({
+                        error: 'Webhook URL must be a valid HTTPS URL',
+                    });
+                }
+            }
+            const updatedConfig = await ProviderService.instance.updateProviderConfiguration(customer.customerId, providerId, {
+                apiEndpoint: apiEndpoint?.trim() || undefined,
+                webhookUrl: webhookUrl?.trim() || undefined,
+                defaultSettings: defaultSettings || undefined,
+            });
+            const safeConfig = {
+                configId: updatedConfig.configId,
+                providerId: updatedConfig.providerId,
+                apiEndpoint: updatedConfig.apiEndpoint,
+                webhookUrl: updatedConfig.webhookUrl,
+                validated: updatedConfig.validated,
+                validatedAt: updatedConfig.validatedAt,
+                active: updatedConfig.active,
+                defaultSettings: updatedConfig.defaultSettings,
+                hasApiKey: !!updatedConfig.encryptedApiKey,
+                updatedAt: updatedConfig.updatedAt,
+            };
+            return res.status(StatusCodes.OK).json({
+                message: 'Provider configuration updated successfully',
+                data: safeConfig,
+            });
+        }
+        catch (error) {
+            const status = error?.message.includes('not found')
+                ? StatusCodes.NOT_FOUND
+                : StatusCodes.BAD_REQUEST;
+            return res.status(status).json({
+                error: `Configuration update failed: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/{providerId}/test:
+     *   post:
+     *     tags: [Providers]
+     *     summary: Test connection to a provider
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Connection test completed
+     *       400:
+     *         description: Connection test failed
+     *       404:
+     *         description: Provider configuration not found
+     */
+    async testConnection(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const { providerId } = req.params;
+            const result = await ProviderService.instance.testConnection(customer.customerId, providerId);
+            const statusCode = result.success ? StatusCodes.OK : StatusCodes.BAD_REQUEST;
+            return res.status(statusCode).json({
+                providerId,
+                success: result.success,
+                message: result.message,
+                testedAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Connection test failed: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     * /providers/{providerId}:
+     *   delete:
+     *     tags: [Providers]
+     *     summary: Remove provider configuration
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     responses:
+     *       200:
+     *         description: Configuration removed successfully
+     */
+    async removeProvider(req, res) {
+        try {
+            const customer = res.locals.customer;
+            const { providerId } = req.params;
+            await ProviderService.instance.deleteConfiguration(customer.customerId, providerId);
+            return res.status(StatusCodes.OK).json({
+                message: `Provider ${providerId} configuration removed successfully`,
+            });
+        }
+        catch (error) {
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Internal error: ${error?.message || error}`,
+            });
+        }
+    }
+    /**
+     * @openapi
+     *
+     * /providers/{providerId}/did/import:
+     *   post:
+     *     tags: [ Providers ]
+     *     summary: Import a DID into a Provider.
+     *     description: This endpoint imports a decentralized identifier associated with the user's account with the custodied keys into a provider.
+     *     parameters:
+     *       - name: providerId
+     *         in: path
+     *         required: true
+     *         schema:
+     *           type: string
+     *     requestBody:
+     *       content:
+     *         application/x-www-form-urlencoded:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - did
+     *             properties:
+     *               did:
+     *                 description: DID identifier to resolve.
+     *                 type: string
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - did
+     *             properties:
+     *               did:
+     *                 description: DID identifier to resolve.
+     *                 type: string
+     *     responses:
+     *       200:
+     *         description: The request was successful.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/DidResult'
+     *       400:
+     *         description: A problem with the input fields has occurred. Additional state information plus metadata may be available in the response body.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/InvalidRequest'
+     *             example:
+     *               error: InvalidRequest
+     *       401:
+     *         $ref: '#/components/schemas/UnauthorizedError'
+     *       500:
+     *         description: An internal error has occurred. Additional state information plus metadata may be available in the response body.
+     *         content:
+     *           application/json:
+     *             schema:
+     *               $ref: '#/components/schemas/InvalidRequest'
+     *             example:
+     *               error: Internal Error
+     */
+    async importDid(request, response) {
+        try {
+            const { providerId } = request.params;
+            const { did } = request.body;
+            let importedResult;
+            switch (providerId) {
+                case 'dock':
+                    const identityServiceStrategySetup = new IdentityServiceStrategySetup(response.locals.customer);
+                    const exportedResult = await identityServiceStrategySetup.agent.exportDid(did, process.env.PROVIDER_EXPORT_PASSWORD || '', response.locals.customer);
+                    importedResult = await new DockIdentityService().importDidV2(did, exportedResult, process.env.PROVIDER_EXPORT_PASSWORD || '', response.locals.customer);
+                    break;
+                default:
+                    throw new Error(`Importing into provider ${providerId || 'studio'} is not supported`);
+            }
+            // Track the operation
+            eventTracker.emit('track', {
+                category: OperationCategoryNameEnum.DID,
+                name: OperationNameEnum.DID_EXPORT,
+                data: {
+                    did: did,
+                },
+                customer: response.locals.customer,
+                user: response.locals.user,
+            });
+            return response.status(StatusCodes.OK).json({
+                status: true,
+                ...importedResult,
+            });
+        }
+        catch (error) {
+            return response.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                error: `Internal error: ${error?.message || error}`,
+            });
+        }
+    }
+}
+__decorate([
+    validate
+], ProvidersController.prototype, "importDid", null);
+//# sourceMappingURL=providers.controller.js.map