avro-to-json-schema/lib/index.js

TypeScript code generator for Apache Avro types

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertFieldDec = exports.convertType = exports.convertEnum = exports.convertRecord = exports.avroToJSONSchema = exports.convertPrimitive = exports.isRecordType = exports.isOptional = exports.isMapType = exports.isLogicalType = exports.isEnumType = exports.isArrayType = void 0;
var _ = require("lodash");
var model_1 = require("./model");
Object.defineProperty(exports, "isArrayType", { enumerable: true, get: function () { return model_1.isArrayType; } });
Object.defineProperty(exports, "isEnumType", { enumerable: true, get: function () { return model_1.isEnumType; } });
Object.defineProperty(exports, "isLogicalType", { enumerable: true, get: function () { return model_1.isLogicalType; } });
Object.defineProperty(exports, "isMapType", { enumerable: true, get: function () { return model_1.isMapType; } });
Object.defineProperty(exports, "isOptional", { enumerable: true, get: function () { return model_1.isOptional; } });
Object.defineProperty(exports, "isRecordType", { enumerable: true, get: function () { return model_1.isRecordType; } });
var model_2 = require("./model");
/** Convert a primitive type from avro to TypeScript */
function convertPrimitive(avroType) {
    switch (avroType) {
        case "long":
        case "int":
            return "Type.Integer()";
        case "double":
        case "float":
            return "Type.Number()";
        case "bytes":
            return "Type.Unknown()";
        case "null":
            return "Type.Null()";
        case "boolean":
            return "Type.Boolean()";
        case "string":
            return "Type.String()";
        default:
            return null;
    }
}
exports.convertPrimitive = convertPrimitive;
/** Converts an Avro record type to a TypeScript file */
function avroToJSONSchema(schema) {
    var output = [];
    var dependencies = [];
    var records = [];
    if ((0, model_2.isEnumType)(schema))
        convertEnum(schema, output);
    else if ((0, model_2.isRecordType)(schema))
        convertRecord(schema, output, dependencies, records);
    else
        throw "Unknown top level type " + schema["type"];
    return { file: output.join("\n"), dependencies: dependencies, records: records };
}
exports.avroToJSONSchema = avroToJSONSchema;
/** Convert an Avro Record type. Return the name, but add the definition to the file */
function convertRecord(recordType, fileBuffer, dependencies, records) {
    var schemaName = _.camelCase(recordType.name + 'Schema');
    var buffer = "export const " + schemaName + " = Type.Object({\n";
    for (var _i = 0, _a = recordType.fields; _i < _a.length; _i++) {
        var field = _a[_i];
        buffer += convertFieldDec(field, fileBuffer, dependencies, records) + "\n";
    }
    buffer += "})\n";
    buffer += "export type " + recordType.name + " = Static<typeof " + schemaName + ">;";
    fileBuffer.push(buffer);
    records.push(schemaName);
    return schemaName;
}
exports.convertRecord = convertRecord;
/** Convert an Avro Enum type. Return the name, but add the definition to the file */
function convertEnum(enumType, fileBuffer) {
    var enumDef = "export const " + enumType.name + " = Type.Union([" + enumType.symbols.map(function (symbol) { return "Type.Literal('" + symbol + "')"; }).join(", ") + "]);\n";
    fileBuffer.push(enumDef);
    return enumType.name;
}
exports.convertEnum = convertEnum;
function convertType(type, buffer, dependencies, records) {
    // if it's just a name, then use that
    if (typeof type === "string") {
        var convertedValue = convertPrimitive(type);
        if (convertedValue) {
            return convertedValue;
        }
        else {
            dependencies.push(_.camelCase(type + 'Schema'));
            return _.camelCase(type + 'Schema');
        }
    }
    else if (type instanceof Array) {
        // array means a Union. Use the names and call recursively
        return "Type.Union([" + type.map(function (t) { return convertType(t, buffer, dependencies, records); }).join(", ") + "])";
    }
    else if ((0, model_2.isRecordType)(type)) {
        //} type)) {
        // record, use the name and add to the buffer
        return convertRecord(type, buffer, dependencies, records);
    }
    else if ((0, model_2.isArrayType)(type)) {
        // array, call recursively for the array element type
        return "Type.Array(" + convertType(type.items, buffer, dependencies, records) + ")";
    }
    else if ((0, model_2.isMapType)(type)) {
        // Dictionary of types, string as key
        return "Type.Record(Type.String(), " + convertType(type.values, buffer, dependencies, records) + ")";
    }
    else if ((0, model_2.isEnumType)(type)) {
        // array, call recursively for the array element type
        return convertEnum(type, buffer);
        // return `Type.Enum(${convertEnum(type, buffer)})`;
        // return `Type.Union([${type.symbols.map(symbol => `Type.Literal(${symbol})`).join(' ,')}])`
    }
    else if ((0, model_2.isLogicalType)(type)) {
        return convertType(type.type, buffer, dependencies, records);
    }
    else {
        console.error("Cannot work out type", type);
        return "UNKNOWN";
    }
}
exports.convertType = convertType;
function convertFieldDec(field, buffer, dependencies, records) {
    // Union Type
    //return `\t${field.name}${isOptional(field.type) ? "?" : ""}: ${convertType(field.type, buffer)};`;
    return "\t" + field.name + ": " + ((0, model_2.isOptional)(field.type) ? "Type.Optional(" + convertType(field.type, buffer, dependencies, records) + ")" : convertType(field.type, buffer, dependencies, records)) + ",";
}
exports.convertFieldDec = convertFieldDec;
//# sourceMappingURL=index.js.map