@cuba-platform/front-generator/lib/common/generation.js

CUBA Platform front-end clients generator

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Base = require("yeoman-generator");
const path = require("path");
const cli_options_1 = require("./cli-options");
const questions_1 = require("./questions");
const fs = require("fs");
class BaseGenerator extends Base {
    constructor(args, options) {
        super(args, options);
        this.options = {};
        this._populateOptions(this._getAvailableOptions());
        this.destinationRoot(this._getDestRoot());
    }
    _promptOrParse() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.options.answers && this.options.model) { // passed from studio
                this.conflicter.force = true;
                const encodedAnswers = Buffer.from(this.options.answers, 'base64').toString('utf8');
                const parsedAnswers = JSON.parse(encodedAnswers);
                this.cubaProjectModel = readProjectModel(this.options.model);
                this.answers = refineAnswers(this.cubaProjectModel, this._getParams(), parsedAnswers);
                return Promise.resolve();
            }
            this.answers = (yield this.prompt(questions_1.fromStudioProperties(this._getParams())));
        });
    }
    _populateOptions(availableOption) {
        Object.keys(availableOption).forEach(optionName => {
            this.option(optionName, availableOption[optionName]);
        });
    }
    _getDestRoot() {
        if (!this.options.dest) {
            return this.destinationRoot();
        }
        if (path.isAbsolute(this.options.dest)) {
            return this.options.dest;
        }
        return path.join(this.destinationRoot(), this.options.dest);
    }
    _getAvailableOptions() {
        return cli_options_1.commonGenerationOptionsConfig;
    }
    _getParams() {
        return [];
    }
}
exports.BaseGenerator = BaseGenerator;
function readProjectModel(modelFilePath) {
    if (!fs.existsSync(modelFilePath)) {
        throw new Error('Specified model file does not exist');
    }
    return JSON.parse(fs.readFileSync(modelFilePath, "utf8"));
}
exports.readProjectModel = readProjectModel;
function findEntity(projectModel, entityInfo) {
    const entityName = entityInfo.name;
    let entity;
    if (Array.isArray(projectModel.entities)) {
        entity = projectModel.entities.find(e => e.name === entityName);
        if (entity != null) {
            return entity;
        }
    }
    else {
        if (projectModel.entities.hasOwnProperty(entityName)) {
            return projectModel.entities[entityName];
        }
    }
    if (projectModel.baseProjectEntities != null) {
        if (Array.isArray(projectModel.baseProjectEntities)) {
            entity = projectModel.baseProjectEntities.find(e => e.name === entityName);
            if (entity != null) {
                return entity;
            }
        }
        else {
            return projectModel.baseProjectEntities[entityName];
        }
    }
}
function findView(projectModel, view) {
    return projectModel.views.find(v => v.name === view.name && v.entity === view.entityName);
}
function findQuery(projectModel, queryInfo) {
    return projectModel.restQueries.find(q => q.entity === queryInfo.entityName && q.name === queryInfo.name);
}
function findServiceMethod(projectModel, methodInfo) {
    const service = projectModel.restServices.find(s => s.name === methodInfo.serviceName);
    if (service != null) {
        const method = service.methods.find(m => m.name === methodInfo.methodName);
        if (method != null) {
            return { service, method };
        }
    }
    return null;
}
function refineAnswers(projectModel, props, answers) {
    const refinedAnswers = {};
    Object.keys(answers).forEach((key) => {
        const prop = props.find(p => p.code === key);
        if (prop == null) {
            refinedAnswers[key] = answers[key];
            return;
        }
        switch (prop.propertyType) {
            case "ENTITY" /* ENTITY */:
                refinedAnswers[key] = findEntity(projectModel, answers[key]);
                return;
            case "VIEW" /* VIEW */:
                refinedAnswers[key] = findView(projectModel, answers[key]);
                return;
            case "REST_QUERY" /* REST_QUERY */:
                refinedAnswers[key] = findQuery(projectModel, answers[key]);
                return;
            case "REST_SERVICE_METHOD" /* REST_SERVICE_METHOD */:
                refinedAnswers[key] = findServiceMethod(projectModel, answers[key]);
                return;
            default:
                refinedAnswers[key] = answers[key];
        }
    });
    return refinedAnswers;
}
//# sourceMappingURL=generation.js.map