typed-aws/lib/src/generator/parser.js

Helps you write AWS CloudFormation in TypeScript

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpecRegistry = exports.parseSpecsJson = exports.parseSpecs = exports.parseSchemaJson = exports.parseSchemaFile = void 0;
const fs_1 = __importDefault(require("fs"));
async function parseSchemaFile(file) {
    const json = await fs_1.default.promises.readFile(file);
    return parseSchemaJson(json.toString());
}
exports.parseSchemaFile = parseSchemaFile;
function parseSchemaJson(json) {
    const schemaObject = JSON.parse(json);
    if (typeof schemaObject !== 'object' || !schemaObject)
        throw new Error(`Invalid schema: ${json}`);
    return parseSchemaRegistry(schemaObject);
}
exports.parseSchemaJson = parseSchemaJson;
function parseSchemaRegistry(schemaObject) {
    const registry = {};
    const schemaTypeName = schemaObject['typeName'];
    const { module, typeName } = toTypeName(schemaTypeName);
    if (!module)
        throw new Error('Module name not detected: ' + schemaTypeName);
    registerType({
        id: schemaTypeName,
        namespace: schemaTypeName,
        module,
        resource: typeName,
        name: typeName,
        root: true,
        type: 'object',
        ...schemaObject,
    }, registry);
    const definitions = schemaObject['definitions'];
    if (definitions) {
        for (const key in definitions) {
            const definition = definitions[key];
            registerType({
                id: `${schemaTypeName}.${key}`,
                namespace: schemaTypeName,
                module,
                resource: typeName,
                name: key,
                ...definition,
            }, registry);
        }
    }
    return registry;
}
function registerType(schema, registry) {
    if (registry[schema.id]) {
        throw new Error(`Type ${schema} already registered`);
    }
    registry[schema.id] = schema;
}
function toTypeName(typeName) {
    const tokens = typeName.split('::');
    if (tokens.length === 3) {
        return { module: tokens[1], typeName: tokens[2] };
    }
    else if (tokens.length === 1) {
        return { typeName: typeName };
    }
    throw new Error(`Unknown Type name format: ${typeName}`);
}
async function parseSpecs(file) {
    const json = await fs_1.default.promises.readFile(file);
    return parseSpecsJson(json.toString());
}
exports.parseSpecs = parseSpecs;
function parseSpecsJson(json) {
    const specsJson = JSON.parse(json);
    if (typeof specsJson !== 'object' || !specsJson)
        throw new Error(`Invalid specs json: ${json}`);
    return new SpecRegistry(specsJson);
}
exports.parseSpecsJson = parseSpecsJson;
class SpecRegistry {
    constructor(spec) {
        this.spec = spec;
    }
    getDocumentation(id, property) {
        const type = this.findType(id);
        if (type) {
            if (!property) {
                return type.Documentation;
            }
            else {
                return type.Properties?.[property]?.Documentation;
            }
        }
    }
    findType(id) {
        const propertyType = this.spec.PropertyTypes[id];
        if (propertyType)
            return propertyType;
        const resourceType = this.spec.ResourceTypes[id];
        if (resourceType)
            return resourceType;
    }
}
exports.SpecRegistry = SpecRegistry;