@boostercloud/cli/dist/services/generator/target/parsing.js

CLI of the Booster Framework, the next level of abstraction for cloud-native applications

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseReaction = exports.parseProjectionField = exports.parseProjections = exports.parseFields = exports.parseEvent = exports.parseName = void 0;
exports.joinParsers = joinParsers;
/* eslint-disable @typescript-eslint/no-non-null-assertion */
/* eslint-disable @typescript-eslint/generic-type-naming */
const parseName = (name) => Promise.resolve({ name });
exports.parseName = parseName;
const parseEvent = (event) => Promise.resolve({ event });
exports.parseEvent = parseEvent;
const parseFields = async (fields) => {
    const parsedFields = await Promise.all(fields.map(parseField));
    const parsedFieldNames = parsedFields.map((field) => field.name);
    const uniqueFieldNames = new Set(parsedFieldNames);
    const duplicates = parsedFieldNames.filter((field) => !uniqueFieldNames.delete(field));
    if (duplicates.length > 0) {
        throw fieldDuplicatedError(duplicates.join(', '));
    }
    return { fields: parsedFields };
};
exports.parseFields = parseFields;
function parseField(rawField) {
    const splitInput = rawField.split(':');
    if (splitInput.length != 2 || splitInput[0].length === 0 || splitInput[1].length === 0) {
        return Promise.reject(fieldParsingError(rawField));
    }
    else {
        return Promise.resolve({
            name: splitInput[0],
            type: splitInput[1],
        });
    }
}
const parseProjections = (fields) => Promise.all(fields.map(parseProjection)).then((projections) => ({ projections }));
exports.parseProjections = parseProjections;
const parseProjectionField = (field) => parseProjection(field).then((projection) => ({ projection }));
exports.parseProjectionField = parseProjectionField;
async function parseProjection(rawProjection) {
    const splitInput = rawProjection.split(':');
    if (splitInput.length != 2 || splitInput[0].length === 0 || splitInput[1].length === 0) {
        throw projectionParsingError(rawProjection);
    }
    else {
        return {
            entityName: splitInput[0],
            entityId: splitInput[1],
        };
    }
}
const parseReaction = (rawEvents) => Promise.all(rawEvents.map(parseReactionEvent)).then((events) => ({
    events,
}));
exports.parseReaction = parseReaction;
const parseReactionEvent = (eventName) => Promise.resolve({ eventName });
const fieldParsingError = (field) => new Error(`Error parsing field ${field}. Fields must be in the form of <field name>:<field type>`);
const fieldDuplicatedError = (field) => new Error(`Error parsing field ${field}. Fields cannot be duplicated`);
const projectionParsingError = (projection) => new Error(`Error parsing projection ${projection}. Projections must be in the form of <entity name>:<entity id>`);
/**
 * Joins parsers together used to generate target information for generators.
 *
 * @example
 * ```typescript
 * const myEntity: Promise<HasName & HasFields & HasReaction> =
 *   joinParsers(
 *     parseName(entityName),
 *     parseFields(rawFields),
 *     parseReaction(events)
 *   )
 * ```
 */
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function joinParsers(...parsers) {
    return parsers.reduce((promiseA, promiseB) => {
        return promiseA.then((a) => promiseB.then((b) => ({ ...a, ...b })));
    });
}