mongoose-management/build/lib/template/create.js

Mongoose schemas management tool

"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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = require("path");
const converter_1 = __importDefault(require("./converter"));
const file_1 = __importDefault(require("./handlers/file"));
const template_1 = __importDefault(require("./handlers/template"));
const helper_1 = require("./helper");
/**
 *
 */
class Create {
    /**
     *
     * @param prompts
     * @param pathProject
     * @param pathTemplates
     * @param prettier
     * @param converter
     */
    constructor(prompts, pathProject, pathTemplates, prettier, converter = new converter_1.default()) {
        this.prompts = prompts;
        this.pathProject = pathProject;
        this.pathTemplates = pathTemplates;
        this.prettier = prettier;
        this.converter = converter;
        this.interfaceName = 'Interface';
    }
    /**
     *
     * @param source
     * @param collections
     */
    exec(destination, collections) {
        return __awaiter(this, void 0, void 0, function* () {
            const spinner = this.prompts.getSpinner();
            const path = path_1.join(this.pathProject, destination.replace(/(^\/|\/$|^\\|\\$)/g, ''));
            const file = new file_1.default(this.pathTemplates, path);
            const template = new template_1.default(file, this.prettier);
            // Checks whether the collection group folder exists (without group name).
            yield helper_1.exists(path_1.dirname(path));
            const data = collections
                .filter((collection) => collection.columns.length > 0)
                .map((collection) => this.getCollectionDataset(collection));
            try {
                spinner.start('Folders are created');
                yield file.createFolders();
                spinner.succeed();
                spinner.start('Documents are created');
                yield template.createCollections(data);
                spinner.succeed();
                spinner.start('Static files are created');
                yield template.createIndex(data);
                yield file.copyStaticFiles();
                spinner.succeed();
            }
            catch (err) {
                spinner.fail();
                throw err;
            }
            yield this.prompts.pressKey();
        });
    }
    /**
     *
     * @param collection
     */
    getCollectionDataset(collection) {
        return Object.assign({}, this.createCollectionNames(collection.name), { interfaceName: this.interfaceName, schemaDefinitions: this.converter.getDefinitions(collection.columns), SchemaIndexes: this.converter.getIndexes(collection.indexes), schemaTypes: this.converter.getTypes(collection.columns) });
    }
    /**
     *
     * @param name
     */
    createCollectionNames(name) {
        const uFirst = (item) => item.substr(0, 1).toUpperCase() + item.substr(1);
        const items = name.split(/[^a-z0-9]/i);
        const nameLower = items.slice(0, 1).concat(items.slice(1).map(uFirst));
        const nameUpper = items.map(uFirst);
        return {
            collectionNameRaw: name,
            collectionNameLower: nameLower.join(''),
            collectionNameUpper: nameUpper.join(''),
        };
    }
}
exports.default = Create;