@sebastienrousseau/crypto-server 0.0.2 → 0.0.8

package/dist/routes/v2/sealedbox.js

@@ -0,0 +1,145 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/sealedbox/seal", {
+        schema: {
+            tags: ["Sealed Box"],
+            summary: "Anonymous public-key encryption (X25519 sealed box)",
+            body: {
+                type: "object",
+                required: ["recipientPublicKey", "plaintext"],
+                additionalProperties: false,
+                properties: {
+                    recipientPublicKey: { type: "string", minLength: 1 },
+                    plaintext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { seal } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/sealedbox")));
+            const { recipientPublicKey, plaintext } = request.body;
+            return reply.send({ data: seal(recipientPublicKey, plaintext) });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encryption");
+        }
+    });
+    app.post("/v2/sealedbox/open", {
+        schema: {
+            tags: ["Sealed Box"],
+            summary: "Decrypt an anonymous sealed box (X25519)",
+            body: {
+                type: "object",
+                required: ["recipientSecretKey", "sealed"],
+                additionalProperties: false,
+                properties: {
+                    recipientSecretKey: { type: "string", minLength: 1 },
+                    sealed: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { open } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/sealedbox")));
+            const { recipientSecretKey, sealed } = request.body;
+            const plaintext = open(recipientSecretKey, sealed);
+            return reply.send({
+                data: Buffer.from(plaintext).toString("utf8"),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Decryption");
+        }
+    });
+    app.post("/v2/sealedbox/seal-pq", {
+        schema: {
+            tags: ["Sealed Box"],
+            summary: "Post-quantum anonymous encryption (X25519 + ML-KEM-768 sealed box)",
+            body: {
+                type: "object",
+                required: ["x25519PublicKey", "mlKemPublicKey", "plaintext"],
+                additionalProperties: false,
+                properties: {
+                    x25519PublicKey: { type: "string", minLength: 1 },
+                    mlKemPublicKey: { type: "string", minLength: 1 },
+                    plaintext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { sealPQ } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/sealedbox")));
+            const { x25519PublicKey, mlKemPublicKey, plaintext } = request.body;
+            return reply.send({
+                data: sealPQ(x25519PublicKey, mlKemPublicKey, plaintext),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encryption");
+        }
+    });
+    app.post("/v2/sealedbox/open-pq", {
+        schema: {
+            tags: ["Sealed Box"],
+            summary: "Decrypt a post-quantum sealed box (X25519 + ML-KEM-768)",
+            body: {
+                type: "object",
+                required: ["x25519SecretKey", "mlKemSecretKey", "sealed"],
+                additionalProperties: false,
+                properties: {
+                    x25519SecretKey: { type: "string", minLength: 1 },
+                    mlKemSecretKey: { type: "string", minLength: 1 },
+                    sealed: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { openPQ } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/sealedbox")));
+            const { x25519SecretKey, mlKemSecretKey, sealed } = request.body;
+            const plaintext = openPQ(x25519SecretKey, mlKemSecretKey, sealed);
+            return reply.send({
+                data: Buffer.from(plaintext).toString("utf8"),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Decryption");
+        }
+    });
+};
+//# sourceMappingURL=sealedbox.js.map

package/dist/routes/v2/secretbox.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=secretbox.d.ts.map

package/dist/routes/v2/secretbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secretbox.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/secretbox.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAyEE"}

package/dist/routes/v2/secretbox.js

@@ -0,0 +1,94 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/secretbox/seal", {
+        schema: {
+            tags: ["Secretbox"],
+            summary: "Encrypt with XChaCha20-Poly1305 (secretbox seal)",
+            body: {
+                type: "object",
+                required: ["key", "plaintext"],
+                additionalProperties: false,
+                properties: {
+                    key: { type: "string", minLength: 1 },
+                    plaintext: { type: "string", minLength: 1 },
+                    aad: { type: "string" },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { seal } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/secretbox")));
+            const { key, plaintext, aad } = request.body;
+            const aadBytes = aad ? Buffer.from(aad, "utf8") : undefined;
+            return reply.send({ data: seal(key, plaintext, aadBytes) });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encryption");
+        }
+    });
+    app.post("/v2/secretbox/open", {
+        schema: {
+            tags: ["Secretbox"],
+            summary: "Decrypt with XChaCha20-Poly1305 (secretbox open)",
+            body: {
+                type: "object",
+                required: ["key", "ciphertext"],
+                additionalProperties: false,
+                properties: {
+                    key: { type: "string", minLength: 1 },
+                    ciphertext: { type: "string", minLength: 1 },
+                    aad: { type: "string" },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { open } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/secretbox")));
+            const { key, ciphertext, aad } = request.body;
+            const aadBytes = aad ? Buffer.from(aad, "utf8") : undefined;
+            const plaintext = open(key, ciphertext, aadBytes);
+            return reply.send({
+                data: Buffer.from(plaintext).toString("utf8"),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Decryption");
+        }
+    });
+};
+//# sourceMappingURL=secretbox.js.map

package/dist/routes/v2/signing.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=signing.d.ts.map

package/dist/routes/v2/signing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/signing.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAQ/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA6EE"}

package/dist/routes/v2/signing.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modern_1 = require("@sebastienrousseau/crypto-lib/dist/modern");
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/sign", {
+        schema: {
+            tags: ["Signing"],
+            summary: "Sign with Ed25519",
+            description: "Create an Ed25519 digital signature over a message.",
+            body: {
+                type: "object",
+                required: ["privateKey", "message"],
+                additionalProperties: false,
+                properties: {
+                    privateKey: { type: "string", minLength: 64, maxLength: 64 },
+                    message: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 10 * 1024 * 1024,
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { privateKey, message } = request.body;
+            const result = (0, modern_1.ed25519Sign)(privateKey, message);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Signing");
+        }
+    });
+    app.post("/v2/verify", {
+        schema: {
+            tags: ["Signing"],
+            summary: "Verify an Ed25519 signature",
+            description: "Verify a digital signature against a message and public key.",
+            body: {
+                type: "object",
+                required: ["publicKey", "message", "signature"],
+                additionalProperties: false,
+                properties: {
+                    publicKey: { type: "string", minLength: 64, maxLength: 64 },
+                    message: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 10 * 1024 * 1024,
+                    },
+                    signature: { type: "string", minLength: 128, maxLength: 128 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { publicKey, message, signature } = request.body;
+            const result = (0, modern_1.ed25519Verify)(publicKey, message, signature);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Verification");
+        }
+    });
+};
+//# sourceMappingURL=signing.js.map

package/dist/routes/v2/stream.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=stream.d.ts.map

package/dist/routes/v2/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/stream.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAuQ/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAIE"}

package/dist/routes/v2/stream.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_lib_1 = require("@sebastienrousseau/crypto-lib");
+const iso20022_1 = require("@sebastienrousseau/crypto-lib/dist/protocols/iso20022");
+const route_helpers_1 = require("../../utils/route-helpers");
+const SIGN_SCHEMA = {
+    tags: ["Streaming"],
+    summary: "Batch sign messages with sub-millisecond throughput",
+    description: "Process high-throughput batch digital signing operations over multiple payloads.",
+    body: {
+        type: "object",
+        required: ["items"],
+        additionalProperties: false,
+        properties: {
+            items: {
+                type: "array",
+                minItems: 1,
+                maxItems: 1000,
+                items: {
+                    type: "object",
+                    required: ["id", "message", "privateKey"],
+                    additionalProperties: false,
+                    properties: {
+                        id: { type: "string" },
+                        message: { type: "string", minLength: 1 },
+                        privateKey: { type: "string", minLength: 64, maxLength: 64 },
+                    },
+                },
+            },
+        },
+    },
+};
+const VERIFY_SCHEMA = {
+    tags: ["Streaming"],
+    summary: "Batch verify digital signatures",
+    description: "Batch verification pipeline for high-concurrency payment and transaction verification.",
+    body: {
+        type: "object",
+        required: ["items"],
+        additionalProperties: false,
+        properties: {
+            items: {
+                type: "array",
+                minItems: 1,
+                maxItems: 1000,
+                items: {
+                    type: "object",
+                    required: ["id", "message", "signature", "publicKey"],
+                    additionalProperties: false,
+                    properties: {
+                        id: { type: "string" },
+                        message: { type: "string", minLength: 1 },
+                        signature: { type: "string", minLength: 1 },
+                        publicKey: { type: "string", minLength: 64, maxLength: 64 },
+                    },
+                },
+            },
+        },
+    },
+};
+const ISO20022_SCHEMA = {
+    tags: ["Wholesale Payments"],
+    summary: "Verify ISO 20022 post-quantum dual-signature envelope",
+    description: "Validates the payload digest and both the Ed25519 and ML-DSA signatures of a pacs.008, pain.001 or camt.053 envelope. Signatures are checked against trustedKeys, the signer's public keys from the caller's own registry; the public keys inside the envelope are ignored.",
+    body: {
+        type: "object",
+        required: ["envelope", "payload", "trustedKeys"],
+        additionalProperties: false,
+        properties: {
+            trustedKeys: {
+                type: "object",
+                required: ["classicalPublicKey", "postQuantumPublicKey"],
+                additionalProperties: false,
+                properties: {
+                    classicalPublicKey: { type: "string", minLength: 1 },
+                    postQuantumPublicKey: { type: "string", minLength: 1 },
+                },
+            },
+            envelope: {
+                type: "object",
+                required: [
+                    "messageId",
+                    "messageType",
+                    "payloadDigest",
+                    "digestAlgorithm",
+                    "timestamp",
+                    "classical",
+                    "postQuantum",
+                ],
+                additionalProperties: false,
+                properties: {
+                    messageId: { type: "string" },
+                    messageType: {
+                        type: "string",
+                        enum: ["pacs.008", "pain.001", "camt.053", "generic"],
+                    },
+                    payloadDigest: { type: "string" },
+                    digestAlgorithm: {
+                        type: "string",
+                        enum: ["sha256", "sha384", "sha512"],
+                    },
+                    timestamp: { type: "string" },
+                    classical: {
+                        type: "object",
+                        required: ["algorithm", "signature", "publicKey"],
+                        additionalProperties: false,
+                        properties: {
+                            algorithm: { type: "string" },
+                            signature: { type: "string" },
+                            publicKey: { type: "string" },
+                        },
+                    },
+                    postQuantum: {
+                        type: "object",
+                        required: ["algorithm", "signature", "publicKey"],
+                        additionalProperties: false,
+                        properties: {
+                            algorithm: {
+                                type: "string",
+                                enum: ["ml-dsa-44", "ml-dsa-65", "ml-dsa-87"],
+                            },
+                            signature: { type: "string" },
+                            publicKey: { type: "string" },
+                        },
+                    },
+                },
+            },
+            payload: {},
+        },
+    },
+};
+function registerBatchSign(app) {
+    app.post("/v2/stream/sign", { schema: SIGN_SCHEMA }, async (request, reply) => {
+        try {
+            const { items } = request.body;
+            const signatures = items.map((item) => {
+                const res = (0, crypto_lib_1.ed25519Sign)(item.privateKey, item.message);
+                return {
+                    id: item.id,
+                    signature: res.signature,
+                    algorithm: "ed25519",
+                };
+            });
+            return reply.send({
+                data: {
+                    count: signatures.length,
+                    signatures,
+                },
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Batch signing");
+        }
+    });
+}
+function registerBatchVerify(app) {
+    app.post("/v2/stream/verify", { schema: VERIFY_SCHEMA }, async (request, reply) => {
+        try {
+            const { items } = request.body;
+            let validCount = 0;
+            const results = items.map((item) => {
+                try {
+                    const res = (0, crypto_lib_1.ed25519Verify)(item.publicKey, item.message, item.signature);
+                    if (res.valid)
+                        validCount++;
+                    return { id: item.id, valid: res.valid };
+                }
+                catch {
+                    return { id: item.id, valid: false };
+                }
+            });
+            return reply.send({
+                data: {
+                    count: results.length,
+                    validCount,
+                    allValid: validCount === results.length,
+                    results,
+                },
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Batch verification");
+        }
+    });
+}
+function registerIso20022Verify(app) {
+    app.post("/v2/stream/iso20022", { schema: ISO20022_SCHEMA }, async (request, reply) => {
+        try {
+            const { envelope, payload, trustedKeys } = request.body;
+            const result = (0, iso20022_1.verifyIso20022Payment)(envelope, payload, {
+                classicalPublicKeyHex: trustedKeys.classicalPublicKey,
+                postQuantumPublicKeyHex: trustedKeys.postQuantumPublicKey,
+            });
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "ISO 20022 verification");
+        }
+    });
+}
+exports.default = (app) => {
+    registerBatchSign(app);
+    registerBatchVerify(app);
+    registerIso20022Verify(app);
+};
+//# sourceMappingURL=stream.js.map

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import * as fastify from "fastify";
+declare function init(): Promise<fastify.FastifyInstance>;
+export { init };
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AA4CnC,iBAAe,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CA0DtD;AAED,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/server.js

@@ -0,0 +1,124 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const constants_1 = require("./config/constants");
+const accepts_1 = __importDefault(require("@fastify/accepts"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const etag_1 = __importDefault(require("@fastify/etag"));
+const compress_1 = __importDefault(require("@fastify/compress"));
+const fastify_healthcheck_1 = __importDefault(require("fastify-healthcheck"));
+const helmet_1 = __importDefault(require("@fastify/helmet"));
+const rate_limit_1 = __importDefault(require("@fastify/rate-limit"));
+const swagger_1 = __importDefault(require("@fastify/swagger"));
+const swagger_ui_1 = __importDefault(require("@fastify/swagger-ui"));
+const crypto_1 = require("crypto");
+const logger_1 = __importDefault(require("./lib/logger"));
+const auth_1 = require("./lib/auth");
+const metering_1 = require("./enterprise/metering");
+const routes_1 = __importDefault(require("./routes"));
+const fastify = __importStar(require("fastify"));
+function isPublicPath(url) {
+    return (0, constants_1.isProbePath)(url) || url.startsWith("/docs");
+}
+async function registerDocs(app) {
+    await app.register(swagger_1.default, {
+        openapi: {
+            info: {
+                title: "Crypto Service Suite API",
+                description: "REST API for low-level cryptographic operations: key generation, encryption, decryption, signing, verification, and revocation.",
+                version: JSON.parse(constants_1.LIB_VERSION),
+            },
+            components: {
+                securitySchemes: {
+                    apiKey: {
+                        type: "apiKey",
+                        name: "x-api-key",
+                        in: "header",
+                    },
+                },
+            },
+            security: [{ apiKey: [] }],
+        },
+    });
+    await app.register(swagger_ui_1.default, {
+        routePrefix: "/docs",
+    });
+}
+async function init() {
+    const app = fastify.fastify(constants_1.fastifyOptions);
+    logger_1.default.info("\n\nEnvironment details: " + constants_1.consoleOutput);
+    app.addHook("onRequest", async (request, reply) => {
+        const reqId = request.headers["x-request-id"] ?? (0, crypto_1.randomUUID)();
+        reply.header("x-request-id", reqId);
+    });
+    app.addHook("onSend", async (request, reply) => {
+        if (request.url.startsWith("/v2/")) {
+            reply.header("Cache-Control", "no-store, no-cache, must-revalidate");
+            reply.header("Pragma", "no-cache");
+        }
+    });
+    await registerDocs(app);
+    await app
+        .register(accepts_1.default, { decorateReply: true })
+        .register(helmet_1.default, constants_1.helmetOptions)
+        .register(cors_1.default, constants_1.corsOptions)
+        .register(etag_1.default)
+        .register(compress_1.default, constants_1.compressOptions)
+        .register(fastify_healthcheck_1.default, constants_1.healthCheckOptions)
+        .register(rate_limit_1.default, {
+        ...constants_1.rateLimitOptions,
+        max: (0, constants_1.resolveRateLimitMax)(),
+    });
+    await (0, auth_1.registerAuth)(app);
+    app.addHook("onRequest", async (request, reply) => {
+        if (isPublicPath(request.url))
+            return;
+        const auth = await (0, auth_1.authenticate)(request, reply);
+        if (!auth)
+            return reply;
+        request.auth = auth;
+    });
+    (0, metering_1.registerMetering)(app);
+    await app.register(async (scope) => {
+        (0, routes_1.default)(scope);
+    });
+    await app.ready();
+    return app;
+}
+//# sourceMappingURL=server.js.map