@lodestar/api/lib/utils/schema.js

A Typescript REST client for the Ethereum Consensus API

import { MediaType } from "./headers.js";
export var Schema;
(function (Schema) {
    Schema[Schema["Uint"] = 0] = "Uint";
    Schema[Schema["UintRequired"] = 1] = "UintRequired";
    Schema[Schema["UintArray"] = 2] = "UintArray";
    Schema[Schema["String"] = 3] = "String";
    Schema[Schema["StringRequired"] = 4] = "StringRequired";
    Schema[Schema["StringArray"] = 5] = "StringArray";
    Schema[Schema["StringArrayRequired"] = 6] = "StringArrayRequired";
    Schema[Schema["UintOrStringRequired"] = 7] = "UintOrStringRequired";
    Schema[Schema["UintOrStringArray"] = 8] = "UintOrStringArray";
    Schema[Schema["Object"] = 9] = "Object";
    Schema[Schema["ObjectArray"] = 10] = "ObjectArray";
    Schema[Schema["AnyArray"] = 11] = "AnyArray";
    Schema[Schema["Boolean"] = 12] = "Boolean";
})(Schema || (Schema = {}));
/**
 * Return JSON schema from a Schema enum. Useful to declare schemas in a succinct format
 */
function getJsonSchemaItem(schema) {
    switch (schema) {
        case Schema.Uint:
        case Schema.UintRequired:
            return { type: "integer", minimum: 0 };
        case Schema.UintArray:
            return { type: "array", items: { type: "integer", minimum: 0 } };
        case Schema.String:
        case Schema.StringRequired:
            return { type: "string" };
        case Schema.StringArray:
        case Schema.StringArrayRequired:
            return { type: "array", items: { type: "string" } };
        case Schema.UintOrStringRequired:
            return { anyOf: [{ type: "string" }, { type: "integer" }] };
        case Schema.UintOrStringArray:
            return { type: "array", items: { anyOf: [{ type: "string" }, { type: "integer" }] } };
        case Schema.Object:
            return { type: "object" };
        case Schema.ObjectArray:
            return { type: "array", items: { type: "object" } };
        case Schema.AnyArray:
            return { type: "array" };
        case Schema.Boolean:
            return { type: "boolean" };
    }
}
function isRequired(schema) {
    switch (schema) {
        case Schema.UintRequired:
        case Schema.StringRequired:
        case Schema.UintOrStringRequired:
        case Schema.StringArrayRequired:
            return true;
        default:
            return false;
    }
}
export function getFastifySchema(schemaDef) {
    const schema = {};
    if (schemaDef.body != null) {
        schema.body = {
            content: {
                [MediaType.json]: {
                    schema: getJsonSchemaItem(schemaDef.body),
                },
                [MediaType.ssz]: {
                    schema: {},
                },
            },
        };
    }
    if (schemaDef.params) {
        schema.params = { type: "object", required: [], properties: {} };
        for (const [key, def] of Object.entries(schemaDef.params)) {
            schema.params.properties[key] = getJsonSchemaItem(def);
            if (isRequired(def)) {
                schema.params.required.push(key);
            }
        }
    }
    if (schemaDef.query) {
        schema.querystring = { type: "object", required: [], properties: {} };
        for (const [key, def] of Object.entries(schemaDef.query)) {
            schema.querystring.properties[key] = getJsonSchemaItem(def);
            if (isRequired(def)) {
                schema.querystring.required.push(key);
            }
        }
    }
    if (schemaDef.headers) {
        schema.headers = { type: "object", required: [], properties: {} };
        for (const [key, def] of Object.entries(schemaDef.headers)) {
            schema.headers.properties[key] = getJsonSchemaItem(def);
            if (isRequired(def)) {
                schema.headers.required.push(key);
            }
        }
    }
    return schema;
}
//# sourceMappingURL=schema.js.map