@citrineos/util/dist/util/swagger.js

The OCPP util module which supplies helpful utilities like cache and queue connectors, etc.

// SPDX-FileCopyrightText: 2025 Contributors to the CitrineOS Project
//
// SPDX-License-Identifier: Apache-2.0
import { HttpHeader, HttpStatus, UnauthorizedError } from '@citrineos/base';
import * as FastifyAuth from '@fastify/auth';
import fastifySwagger from '@fastify/swagger';
import fastifySwaggerUi from '@fastify/swagger-ui';
import fs from 'fs';
import { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
import * as packageJson from '../../package.json' with { type: 'json' };
/**
 * This transformation is used to set default tags
 *
 * @param {object} swaggerObject - The original Swagger object to be transformed.
 * @param {object} openapiObject - The original OpenAPI object to be transformed.
 * @return {object} The transformed OpenAPI object.
 */
function OcppTransformObject({ swaggerObject, openapiObject, }) {
    console.log('OcppTransformObject: Transforming OpenAPI object...');
    if (openapiObject.paths && openapiObject.components) {
        for (const pathKey in openapiObject.paths) {
            const path = openapiObject.paths[pathKey];
            if (path) {
                for (const methodKey in path) {
                    const method = path[methodKey];
                    if (method) {
                        // Set tags based on path key if tags were not passed in
                        if (!method.tags) {
                            // Get tag index
                            // e.g, '/ocpp/1.6/evdriver' -> 'evdriver'
                            // e.g, '/data/evdriver' -> 'evdriver'
                            const pathSegments = pathKey.split('/');
                            const tagIndex = pathSegments.find((segment) => segment === 'data') ? 2 : 3;
                            method.tags = pathKey
                                .split('/')
                                .slice(tagIndex, -1)
                                .map((tag) => tag.charAt(0).toUpperCase() + tag.slice(1));
                        }
                    }
                }
            }
        }
    }
    return openapiObject;
}
const registerSwaggerUi = (systemConfig, server) => {
    const swaggerUiOptions = {
        routePrefix: systemConfig.util.swagger?.path,
        securityDefinitions: {
            authorization: {
                name: 'authorization',
                type: 'apiKey',
                in: 'header',
            },
        },
        exposeRoute: true,
        uiConfig: {
            filter: true,
        },
        theme: {
            title: 'CitrineOS Central System API',
            css: [
                {
                    filename: '',
                    content: '.swagger-ui .topbar { background-color: #fafafa; } .swagger-ui .topbar .download-url-wrapper { display: none; }',
                },
            ],
        },
    };
    if (systemConfig.util.swagger?.logoPath) {
        swaggerUiOptions['logo'] = {
            type: 'image/png',
            content: fs.readFileSync(systemConfig.util.swagger?.logoPath),
        };
    }
    server.register(fastifySwaggerUi, swaggerUiOptions);
};
export const getHeaderValue = (headers, key) => {
    for (let i = 0; i < headers.length; i += 2) {
        if (headers[i].toLowerCase() === key.toLowerCase()) {
            return headers[i + 1];
        }
    }
    return undefined;
};
const getTokenFromAuthHeader = (authorizationHeader) => {
    if (!!authorizationHeader) {
        const token = authorizationHeader.split('Bearer ')[1];
        return token;
    }
    return undefined;
};
const getAuthorizationTokenFromRawHeaders = (headers) => {
    const authorizationHeader = getHeaderValue(headers, HttpHeader.Authorization);
    return getTokenFromAuthHeader(authorizationHeader);
};
export const getAuthorizationTokenFromRequest = (request) => {
    const token = getAuthorizationTokenFromRawHeaders(request.raw.rawHeaders);
    if (!token) {
        throw new UnauthorizedError('Token not found in headers');
    }
    return token;
};
const registerFastifyAuth = async (server) => {
    await server.register(FastifyAuth).after();
    console.log(server.authorization);
    server.decorate('authorization', function (request, reply, done) {
        try {
            const token = getAuthorizationTokenFromRequest(request);
            console.log('Received authorization token', token);
            done();
        }
        catch (e) {
            reply.code(HttpStatus.UNAUTHORIZED);
        }
    });
};
const buildLocalReference = (json, _parent, _property, i) => {
    // If title is missing but $id is available, set title to $id
    if (!json.title && json.$id) {
        json.title = json.$id;
    }
    // Return title if available, otherwise fallback to $id, or def-<index> as a last resort
    return json.title || json.$id || `def-${i}`;
};
const registerFastifySwagger = (systemConfig, server) => {
    server.register(fastifySwagger, {
        openapi: {
            info: {
                title: 'CitrineOS Central System API',
                description: 'Central System API for OCPP 2.0.1 messaging.',
                version: packageJson.default.version,
            },
            components: {
                securitySchemes: {
                    authorization: {
                        type: 'http',
                        scheme: 'bearer',
                    },
                },
            },
        },
        transformObject: OcppTransformObject,
        refResolver: {
            buildLocalReference,
        },
    });
};
export async function initSwagger(systemConfig, server) {
    registerFastifySwagger(systemConfig, server);
    registerSwaggerUi(systemConfig, server);
    await registerFastifyAuth(server);
}
//# sourceMappingURL=swagger.js.map