@abyss-project/console 1.0.1

package/dist/frameworks/express/decorators.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = exports.Params = exports.Body = exports.Middlewares = exports.Middleware = exports.Controller = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = void 0;
+const types_1 = require("../../types");
+const _1 = require(".");
+const joi_to_swagger_1 = __importDefault(require("joi-to-swagger"));
+function Route(options) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(_1.ROUTE_WATERMARK, true, target, propertyKey);
+        Reflect.defineMetadata(_1.PATH_WATERMARK, options.path, target, propertyKey);
+        Reflect.defineMetadata(_1.METHOD_WATERMARK, options.method, target, propertyKey);
+        Reflect.defineMetadata(_1.OPTIONS_WATERMARK, options, target, propertyKey);
+        if (options.docs) {
+            Reflect.defineMetadata(_1.DOCS_WATERMARK, options.docs, target, propertyKey);
+        }
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            args[1].locals.shouldNotPublishLog =
+                typeof options === 'string' ? false : options.shouldNotPublishLog;
+            return originalMethod.apply(target, args);
+        };
+    };
+}
+function Get(options, docs) {
+    return Route({
+        ...(typeof options === 'string' ? { path: options } : options),
+        docs,
+        method: types_1.APIMethod.GET,
+    });
+}
+exports.Get = Get;
+function Post(options, docs) {
+    return Route({
+        ...(typeof options === 'string' ? { path: options } : options),
+        docs,
+        method: types_1.APIMethod.POST,
+    });
+}
+exports.Post = Post;
+function Put(options, docs) {
+    return Route({
+        ...(typeof options === 'string' ? { path: options } : options),
+        docs,
+        method: types_1.APIMethod.PUT,
+    });
+}
+exports.Put = Put;
+function Delete(options, docs) {
+    return Route({
+        ...(typeof options === 'string' ? { path: options } : options),
+        docs,
+        method: types_1.APIMethod.DELETE,
+    });
+}
+exports.Delete = Delete;
+function Patch(options, docs) {
+    return Route({
+        ...(typeof options === 'string' ? { path: options } : options),
+        docs,
+        method: types_1.APIMethod.PATCH,
+    });
+}
+exports.Patch = Patch;
+function Controller(options) {
+    const defaultPath = '/';
+    return function (target) {
+        var _a;
+        Reflect.defineMetadata(_1.CONTROLLER_WATERMARK, true, target);
+        Reflect.defineMetadata(_1.MASKED_WATERMARK, (typeof options === 'string' ? false : options.isMasked) || false, target);
+        Reflect.defineMetadata(_1.PATH_WATERMARK, (typeof options === 'string' ? options : options.prefixPath) || defaultPath, target);
+        const existingMiddlewares = Reflect.getMetadata(_1.MIDDLEWARE_HOOK_WATERMARK, target) || [];
+        Reflect.defineMetadata(_1.MIDDLEWARE_HOOK_WATERMARK, (typeof options === 'string'
+            ? existingMiddlewares
+            : [
+                ...existingMiddlewares,
+                ...(((_a = options.middlewares) === null || _a === void 0 ? void 0 : _a.map((middleware) => middleware.name)) || []),
+            ]) || existingMiddlewares, target);
+    };
+}
+exports.Controller = Controller;
+function Middleware() {
+    return function (target) {
+        Reflect.defineMetadata(_1.MIDDLEWARE_WATERMARK, true, target);
+    };
+}
+exports.Middleware = Middleware;
+function Middlewares(middlewares) {
+    return function (target, propertyKey) {
+        const existingMiddlewares = Reflect.getMetadata(_1.MIDDLEWARE_HOOK_WATERMARK, target) || [];
+        Reflect.defineMetadata(_1.MIDDLEWARE_HOOK_WATERMARK, [...existingMiddlewares, ...((middlewares === null || middlewares === void 0 ? void 0 : middlewares.map((middleware) => middleware.name)) || [])] ||
+            existingMiddlewares, target, propertyKey);
+    };
+}
+exports.Middlewares = Middlewares;
+function Body(schema, options) {
+    return function (target, propertyKey, descriptor) {
+        const existingDocs = Reflect.getMetadata(_1.DOCS_WATERMARK, target, propertyKey) || {};
+        if (!existingDocs.body) {
+            existingDocs.body = {};
+        }
+        if (!(options === null || options === void 0 ? void 0 : options.shouldNotGenerateSwagger)) {
+            existingDocs.body.content = (0, joi_to_swagger_1.default)(schema).swagger;
+        }
+        Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const result = schema.options({ presence: 'required' }).validate(args[0].body);
+            if (result.error) {
+                throw result.error;
+            }
+            args[0].body = result.value;
+            return originalMethod.apply(target, args);
+        };
+    };
+}
+exports.Body = Body;
+function Params(schema, options) {
+    return function (target, propertyKey, descriptor) {
+        const existingDocs = Reflect.getMetadata(_1.DOCS_WATERMARK, target, propertyKey) || {};
+        if (!existingDocs.params) {
+            existingDocs.params = {};
+        }
+        if (!(options === null || options === void 0 ? void 0 : options.shouldNotGenerateSwagger)) {
+            existingDocs.params.content = (0, joi_to_swagger_1.default)(schema).swagger;
+        }
+        Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const result = schema.options({ presence: 'required' }).validate(args[0].params);
+            if (result.error) {
+                throw result.error;
+            }
+            args[0].params = result.value;
+            return originalMethod.apply(target, args);
+        };
+    };
+}
+exports.Params = Params;
+function Query(schema, options) {
+    return function (target, propertyKey, descriptor) {
+        const existingDocs = Reflect.getMetadata(_1.DOCS_WATERMARK, target, propertyKey) || {};
+        if (!existingDocs.query) {
+            existingDocs.query = {};
+        }
+        if (!(options === null || options === void 0 ? void 0 : options.shouldNotGenerateSwagger)) {
+            existingDocs.query.content = (0, joi_to_swagger_1.default)(schema).swagger;
+        }
+        Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const result = schema.options({ presence: 'required' }).validate(args[0].query);
+            if (result.error) {
+                throw result.error;
+            }
+            args[0].query = result.value;
+            return originalMethod.apply(target, args);
+        };
+    };
+}
+exports.Query = Query;

package/dist/frameworks/express/index.d.ts

@@ -0,0 +1,17 @@
+export * from './decorators';
+export * from './metadata';
+import 'reflect-metadata';
+import express, { Router } from 'express-serve-static-core';
+type Options = {
+    prefix: string;
+    middlewares: any[];
+    controllers: any[];
+    router: (option: any) => Router;
+    disableTrustProxy?: boolean;
+};
+export declare const controllerLoader: (app: express.Application, options: Options) => Promise<{
+    swagger: {
+        tags: string[];
+        paths: Record<string, any>;
+    };
+}>;

package/dist/frameworks/express/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllerLoader = void 0;
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./metadata"), exports);
+const metadata_1 = require("./metadata");
+require("reflect-metadata");
+const types_1 = require("../../types");
+const controllerLoader = async (app, options) => {
+    var _a, _b, _c, _d;
+    try {
+        if (options.disableTrustProxy !== true) {
+            app.set('trust proxy', true);
+        }
+        const middlewares = options.middlewares.map((middleware) => new middleware());
+        const controllers = options.controllers;
+        const tags = [];
+        const paths = {};
+        const mainRouter = options.router({ mergeParams: true });
+        for (const controller of controllers) {
+            const instance = new controller();
+            const isMasked = Reflect.getMetadata(metadata_1.MASKED_WATERMARK, controller);
+            const middlewareHooks = Reflect.getMetadata(metadata_1.MIDDLEWARE_HOOK_WATERMARK, controller) || [];
+            const controllerPrefix = Reflect.getMetadata(metadata_1.PATH_WATERMARK, controller);
+            const tag = controller.name;
+            if (!isMasked) {
+                tags.push(tag);
+            }
+            const router = options.router({ mergeParams: true });
+            const middlewaresToUseOnController = middlewareHooks.map((element) => {
+                const middleware = middlewares.find((middleware) => {
+                    return middleware.constructor.name === element;
+                });
+                if (!middleware) {
+                    console.error(`Middleware ${element} on controller ${controller} do not exist`);
+                }
+                return middleware;
+            });
+            for (const method of Object.getOwnPropertyNames(controller.prototype)) {
+                if (!isRoute(instance, method)) {
+                    continue;
+                }
+                const routeOptions = Reflect.getMetadata(metadata_1.OPTIONS_WATERMARK, instance, method);
+                const path = Reflect.getMetadata(metadata_1.PATH_WATERMARK, instance, method);
+                const docs = Reflect.getMetadata(metadata_1.DOCS_WATERMARK, instance, method) || {};
+                const apiMethod = Reflect.getMetadata(metadata_1.METHOD_WATERMARK, instance, method);
+                const routeMiddlewareHooks = Reflect.getMetadata(metadata_1.MIDDLEWARE_HOOK_WATERMARK, instance, method) || [];
+                const fullPath = `${routeOptions.shouldSkipController ? '' : controllerPrefix}${path}`;
+                if (!paths[fullPath]) {
+                    paths[fullPath] = {};
+                }
+                if (!docs.isMasked && !isMasked) {
+                    paths[fullPath][types_1.APIMethod[apiMethod].toLowerCase()] = {
+                        tags: [tag],
+                        description: docs.description || '',
+                        requestBody: {
+                            description: (_a = docs.body) === null || _a === void 0 ? void 0 : _a.description,
+                            content: {
+                                'application/json': {
+                                    schema: (_b = docs === null || docs === void 0 ? void 0 : docs.body) === null || _b === void 0 ? void 0 : _b.content,
+                                },
+                            },
+                        },
+                        parameters: [
+                            ...Object.entries(((_c = docs.params) === null || _c === void 0 ? void 0 : _c.content.properties) || {}).map(([key, entry]) => {
+                                return {
+                                    name: key,
+                                    in: 'path',
+                                    description: entry.description || '',
+                                    required: true,
+                                    schema: entry,
+                                };
+                            }),
+                            ...Object.entries(((_d = docs.query) === null || _d === void 0 ? void 0 : _d.content.properties) || {}).map(([key, entry]) => {
+                                return {
+                                    name: key,
+                                    in: 'query',
+                                    description: entry.description || '',
+                                    required: true,
+                                    schema: entry,
+                                };
+                            }),
+                        ],
+                        responses: {},
+                    };
+                }
+                const middlewaresToUseOnRoute = routeMiddlewareHooks.map((element) => {
+                    const middleware = middlewares.find((middleware) => middleware.constructor.name === element);
+                    if (!middleware) {
+                        console.error(`Middleware ${element} on controller ${controller} on route ${path} do not exist`);
+                    }
+                    return middleware;
+                });
+                const routerToUse = routeOptions.shouldSkipController ? mainRouter : router;
+                switch (apiMethod) {
+                    case types_1.APIMethod.DELETE:
+                        routerToUse.delete(path, ...(routeOptions.shouldSkipController
+                            ? []
+                            : middlewaresToUseOnController.map((middleware) => middleware.run)), setLocalsMiddleware(controller, options, fullPath, null), ...middlewaresToUseOnRoute.map((middleware) => middleware.run), instance[method]);
+                        break;
+                    case types_1.APIMethod.GET:
+                        routerToUse.get(path, ...(routeOptions.shouldSkipController
+                            ? []
+                            : middlewaresToUseOnController.map((middleware) => middleware.run)), setLocalsMiddleware(controller, options, fullPath, null), ...middlewaresToUseOnRoute.map((middleware) => middleware.run), instance[method]);
+                        break;
+                    case types_1.APIMethod.POST:
+                        routerToUse.post(path, ...(routeOptions.shouldSkipController
+                            ? []
+                            : middlewaresToUseOnController.map((middleware) => middleware.run)), setLocalsMiddleware(controller, options, fullPath, null), ...middlewaresToUseOnRoute.map((middleware) => middleware.run), instance[method]);
+                        break;
+                    case types_1.APIMethod.PUT:
+                        routerToUse.put(path, ...(routeOptions.shouldSkipController
+                            ? []
+                            : middlewaresToUseOnController.map((middleware) => middleware.run)), setLocalsMiddleware(controller, options, fullPath, null), ...middlewaresToUseOnRoute.map((middleware) => middleware.run), instance[method]);
+                        break;
+                    case types_1.APIMethod.PATCH:
+                        routerToUse.patch(path, ...(routeOptions.shouldSkipController
+                            ? []
+                            : middlewaresToUseOnController.map((middleware) => middleware.run)), setLocalsMiddleware(controller, options, fullPath, null), ...middlewaresToUseOnRoute.map((middleware) => middleware.run), instance[method]);
+                        break;
+                    default:
+                        console.error(`Method ${apiMethod} on route ${path} of controller ${controller} do not exist`);
+                        break;
+                }
+            }
+            mainRouter.use(`${controllerPrefix}`, setLocalsMiddleware(controller, options, controllerPrefix), router);
+        }
+        app.use(options.prefix, mainRouter);
+        return {
+            swagger: {
+                tags,
+                paths,
+            },
+        };
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+};
+exports.controllerLoader = controllerLoader;
+const isRoute = (target, propertyKey) => {
+    try {
+        if (Reflect.getMetadata(metadata_1.ROUTE_WATERMARK, target, propertyKey)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+};
+const setLocalsMiddleware = (controller, options = { prefix: '/' }, controllerPrefix, path) => (req, res, next) => {
+    res.locals.controller = controller.name;
+    res.locals.path = `${options.prefix}${controllerPrefix}${path !== null ? path || req.path : ''}`;
+    next();
+};

package/dist/frameworks/express/metadata.d.ts

@@ -0,0 +1,9 @@
+export declare const CONTROLLER_WATERMARK = "__controller__";
+export declare const MASKED_WATERMARK = "__masked__";
+export declare const PATH_WATERMARK = "__path__";
+export declare const METHOD_WATERMARK = "__method__";
+export declare const OPTIONS_WATERMARK = "__OPTIONS__";
+export declare const ROUTE_WATERMARK = "__route__";
+export declare const DOCS_WATERMARK = "__docs__";
+export declare const MIDDLEWARE_WATERMARK = "__middleware__";
+export declare const MIDDLEWARE_HOOK_WATERMARK = "__middleware_hook__";

package/dist/frameworks/express/metadata.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIDDLEWARE_HOOK_WATERMARK = exports.MIDDLEWARE_WATERMARK = exports.DOCS_WATERMARK = exports.ROUTE_WATERMARK = exports.OPTIONS_WATERMARK = exports.METHOD_WATERMARK = exports.PATH_WATERMARK = exports.MASKED_WATERMARK = exports.CONTROLLER_WATERMARK = void 0;
+exports.CONTROLLER_WATERMARK = '__controller__';
+exports.MASKED_WATERMARK = '__masked__';
+exports.PATH_WATERMARK = '__path__';
+exports.METHOD_WATERMARK = '__method__';
+exports.OPTIONS_WATERMARK = '__OPTIONS__';
+exports.ROUTE_WATERMARK = '__route__';
+exports.DOCS_WATERMARK = '__docs__';
+exports.MIDDLEWARE_WATERMARK = '__middleware__';
+exports.MIDDLEWARE_HOOK_WATERMARK = '__middleware_hook__';

package/dist/frameworks/index.d.ts

@@ -0,0 +1 @@
+export * from './express';

package/dist/frameworks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./express"), exports);

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { IAxiosRetryConfig } from 'axios-retry';
+import * as workflowApi from './api/workflow.api';
+import * as workflowAdminApi from './api/workflow.admin.api';
+import * as domainVerificationApi from './api/domain-verification.api';
+import * as domainVerificationAdminApi from './api/domain-verification.admin.api';
+import * as monitorApi from './api/monitor.api';
+export * from './types';
+export * from './utils';
+export declare const API_KEY_APPLICATION_HEADER = "abyss-console-api-key-application";
+export declare const ADMIN_TOKEN_HEADER = "abyss-admin-token";
+export declare const HEADER_WEBHOOK_SIGNATURE_NAME = "abyss-console-webhook-signature";
+export declare const WEBHOOK_SIGNATURE_ALGORITHM = "sha256";
+type CoreConfig<TAdmin extends boolean = false> = {
+    token?: string;
+    applicationApiKey?: string;
+    applicationId?: string;
+    adminToken?: string;
+    baseURL?: string;
+    admin?: TAdmin;
+};
+type WorkflowAdminSDK = {
+    paginate: typeof workflowAdminApi.paginateWorkflowAdmin;
+    get: typeof workflowAdminApi.getWorkflowAdmin;
+    updateStatus: typeof workflowAdminApi.updateStatusWorkflowAdmin;
+    delete: typeof workflowAdminApi.deleteWorkflowAdmin;
+    trigger: typeof workflowAdminApi.triggerWorkflowAdmin;
+    execution: {
+        paginate: typeof workflowAdminApi.paginateWorkflowExecutionAdmin;
+        cancel: typeof workflowAdminApi.cancelWorkflowExecutionAdmin;
+    };
+};
+type DomainVerificationAdminSDK = {
+    runCron: typeof domainVerificationAdminApi.runCron;
+};
+type AbyssConsoleCoreSDK<TAdmin extends boolean = false> = {
+    workflow: {
+        create: typeof workflowApi.createWorkflow;
+        paginate: typeof workflowApi.paginateWorkflow;
+        get: typeof workflowApi.getWorkflow;
+        update: typeof workflowApi.updateWorkflow;
+        updateStatus: typeof workflowApi.updateStatusWorkflow;
+        delete: typeof workflowApi.deleteWorkflow;
+        step: {
+            create: typeof workflowApi.createWorkflowStep;
+            list: typeof workflowApi.listWorkflowSteps;
+            update: typeof workflowApi.updateWorkflowStep;
+            delete: typeof workflowApi.deleteWorkflowStep;
+        };
+        execution: {
+            paginate: typeof workflowApi.paginateWorkflowExecution;
+            get: typeof workflowApi.getWorkflowExecution;
+            stats: typeof workflowApi.getStatsWorkflowExecution;
+            cancel: typeof workflowApi.cancelWorkflowExecution;
+        };
+    } & (TAdmin extends true ? {
+        admin: WorkflowAdminSDK;
+    } : {});
+    domainVerification: {
+        create: typeof domainVerificationApi.createDomainVerification;
+        list: typeof domainVerificationApi.listDomainVerification;
+        get: typeof domainVerificationApi.getDomainVerification;
+        verify: typeof domainVerificationApi.verifyDomainVerification;
+        regenerate: typeof domainVerificationApi.regenerateDomainVerification;
+        delete: typeof domainVerificationApi.deleteDomainVerification;
+    } & (TAdmin extends true ? {
+        admin: DomainVerificationAdminSDK;
+    } : {});
+    monitor: {
+        up: typeof monitorApi.upMonitor;
+    };
+};
+export declare class AbyssConsoleCore {
+    private static config;
+    static axios: import("axios").AxiosInstance;
+    private static _sdk;
+    static get sdk(): AbyssConsoleCoreSDK<false> | AbyssConsoleCoreSDK<true>;
+    private static buildSDK;
+    static setConfig<TAdmin extends boolean = false>(config: CoreConfig<TAdmin>): void;
+    static getConfig(): CoreConfig & {
+        admin: boolean;
+    };
+    static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void;
+}

package/dist/index.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbyssConsoleCore = exports.WEBHOOK_SIGNATURE_ALGORITHM = exports.HEADER_WEBHOOK_SIGNATURE_NAME = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_APPLICATION_HEADER = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importStar(require("axios-retry"));
+const workflowApi = __importStar(require("./api/workflow.api"));
+const workflowAdminApi = __importStar(require("./api/workflow.admin.api"));
+const domainVerificationApi = __importStar(require("./api/domain-verification.api"));
+const domainVerificationAdminApi = __importStar(require("./api/domain-verification.admin.api"));
+const monitorApi = __importStar(require("./api/monitor.api"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+const MONITOR_DEFAULT_BASE_URL = 'https://console-api.abyss-project.fr/api/';
+exports.API_KEY_APPLICATION_HEADER = 'abyss-console-api-key-application';
+exports.ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+exports.HEADER_WEBHOOK_SIGNATURE_NAME = 'abyss-console-webhook-signature';
+exports.WEBHOOK_SIGNATURE_ALGORITHM = 'sha256';
+const NUMBER_RETRY_API = 10;
+const BASE_DELAY_BETWEEN_RETRY = 5000;
+const RETRY_CODES = [
+    502,
+    503,
+];
+class AbyssConsoleCore {
+    static get sdk() {
+        if (!_a._sdk) {
+            _a._sdk = _a.buildSDK();
+        }
+        return _a._sdk;
+    }
+    static buildSDK() {
+        const workflowSDK = {
+            create: workflowApi.createWorkflow,
+            paginate: workflowApi.paginateWorkflow,
+            get: workflowApi.getWorkflow,
+            update: workflowApi.updateWorkflow,
+            updateStatus: workflowApi.updateStatusWorkflow,
+            delete: workflowApi.deleteWorkflow,
+            step: {
+                create: workflowApi.createWorkflowStep,
+                list: workflowApi.listWorkflowSteps,
+                update: workflowApi.updateWorkflowStep,
+                delete: workflowApi.deleteWorkflowStep,
+            },
+            execution: {
+                paginate: workflowApi.paginateWorkflowExecution,
+                get: workflowApi.getWorkflowExecution,
+                stats: workflowApi.getStatsWorkflowExecution,
+                cancel: workflowApi.cancelWorkflowExecution,
+            },
+        };
+        if (_a.config.admin) {
+            workflowSDK.admin = {
+                paginate: workflowAdminApi.paginateWorkflowAdmin,
+                get: workflowAdminApi.getWorkflowAdmin,
+                updateStatus: workflowAdminApi.updateStatusWorkflowAdmin,
+                delete: workflowAdminApi.deleteWorkflowAdmin,
+                trigger: workflowAdminApi.triggerWorkflowAdmin,
+                execution: {
+                    paginate: workflowAdminApi.paginateWorkflowExecutionAdmin,
+                    cancel: workflowAdminApi.cancelWorkflowExecutionAdmin,
+                },
+            };
+        }
+        const domainVerificationSDK = {
+            create: domainVerificationApi.createDomainVerification,
+            list: domainVerificationApi.listDomainVerification,
+            get: domainVerificationApi.getDomainVerification,
+            verify: domainVerificationApi.verifyDomainVerification,
+            regenerate: domainVerificationApi.regenerateDomainVerification,
+            delete: domainVerificationApi.deleteDomainVerification,
+        };
+        if (_a.config.admin) {
+            domainVerificationSDK.admin = {
+                runCron: domainVerificationAdminApi.runCron,
+            };
+        }
+        const baseSDK = {
+            workflow: workflowSDK,
+            domainVerification: domainVerificationSDK,
+            monitor: {
+                up: monitorApi.upMonitor,
+            },
+        };
+        return baseSDK;
+    }
+    static setConfig(config) {
+        _a.config = { ..._a.config, ...config, admin: config.admin || false };
+        _a._sdk = null;
+        if (config.baseURL) {
+            _a.axios.defaults.baseURL = config.baseURL;
+        }
+        if (config.token) {
+            _a.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+        }
+        if (config.adminToken) {
+            _a.axios.defaults.headers.common[exports.ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+        }
+        if (config.applicationApiKey) {
+            _a.axios.defaults.headers.common[exports.API_KEY_APPLICATION_HEADER] = `${config.applicationApiKey}`;
+        }
+    }
+    static getConfig() {
+        return _a.config;
+    }
+    static enableAxiosRetry(axiosRetryConfig) {
+        (0, axios_retry_1.default)(_a.axios, {
+            retries: NUMBER_RETRY_API,
+            retryDelay: (retryCount) => retryCount * BASE_DELAY_BETWEEN_RETRY,
+            retryCondition: (error) => {
+                var _b;
+                return (0, axios_retry_1.isNetworkOrIdempotentRequestError)(error) ||
+                    RETRY_CODES.includes(((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) || 502);
+            },
+            ...axiosRetryConfig,
+        });
+    }
+}
+exports.AbyssConsoleCore = AbyssConsoleCore;
+_a = AbyssConsoleCore;
+AbyssConsoleCore.config = {
+    token: '',
+    applicationApiKey: '',
+    applicationId: '',
+    adminToken: '',
+    baseURL: MONITOR_DEFAULT_BASE_URL,
+    admin: false,
+};
+AbyssConsoleCore.axios = axios_1.default.create({
+    baseURL: _a.config.baseURL,
+    withCredentials: true,
+});
+AbyssConsoleCore._sdk = null;

package/dist/middlewares/context.middleware.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from 'express-serve-static-core';
+type StoreEntry = {
+    requestId: string;
+    data: Record<string, unknown>;
+};
+export declare const contextMiddleware: (req: Request, res: Response<any, any>, next: NextFunction) => void;
+export declare const createRequestContext: (data: Record<string, unknown>, requestId?: string) => {
+    requestId: string;
+    data: Record<string, unknown>;
+};
+export declare const getRequestContext: () => StoreEntry;
+export {};