typescript-mysql-model/lib/getter-builder.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const change_case = require("change-case");
const handlebars = require("handlebars");
const schema_operator_1 = require("./schema-operator");
const TEMPLATE = `/**
 * Auto generated, do not modify!
 */
/* eslint-disable */
import * as Knex from "knex";
{{#each imports}}{{{this}}}
{{/each}}

export default class Getter {
    constructor(private knex: Knex) {

    }

    private async getSingle(tableName: string, keyObject: { [key: string]: any }, fn?: (knex: Knex.QueryBuilder) => Knex.QueryBuilder | void): Promise<any> {
        let query = this.knex(tableName).select().limit(1).where(keyObject);
        if (fn) {
            const subQuery = fn(query);
            if(subQuery){
                query = subQuery;
            }
        } 
        const reply: any[] = await query;
        return reply.shift();        
    }

    private async getFromTable(tableName: string, fn?: (knex: Knex.QueryBuilder) => Knex.QueryBuilder | void): Promise<any[]> {
        let query = this.knex(tableName).select();
        if (fn) {
            const subQuery = fn(query);
            if(subQuery){
                query = subQuery;
            }
        }
        return await query;
    }

{{#each getters}}{{{this}}}{{/each}}
{{#each singulars}}{{{this}}}{{/each}}
}`;
const GET_TEMPLATE = `
    public list{{fnName}}(fn?: (knex: Knex.QueryBuilder) => Knex.QueryBuilder | void): Promise<{{prefixedClassName}}[]> {
        return this.getFromTable("{{tableName}}", fn);
    }
`;
const GET_SINGULAR = `
    public getSingle{{fnName}}({{#each params}}{{{this}}}{{#unless @last}},{{/unless}}{{/each}}, fn?: (knex: Knex.QueryBuilder) => Knex.QueryBuilder | void): Promise<{{prefixedClassName}}> {
        return this.getSingle("{{tableName}}", { {{#each fields}}{{{this}}}{{#unless @last}},{{/unless}}{{/each}} } ,fn);
    }
`;
class GettersBuilder extends schema_operator_1.SchemaOperator {
    constructor(model, typeMap) {
        super();
        this.typeMap = typeMap;
        this.definition = model;
        this.compiledTemplate = handlebars.compile(TEMPLATE);
        this.compiledGetTemplate = handlebars.compile(GET_TEMPLATE);
        this.compailedGetSingularTemplate = handlebars.compile(GET_SINGULAR);
    }
    render(tables, relativePath = "./") {
        tables = [...tables];
        tables.forEach(t => {
            t.fnName = change_case.upperCaseFirst(t.fnName);
            t.fnPlural = change_case.upperCaseFirst(t.fnPlural);
        });
        const input = {
            getters: tables.map(t => this.compiledGetTemplate(t)),
            imports: tables.map(t => this.renderImportRow(t, relativePath)),
            singulars: tables.filter(t => t.isTable).map(t => this.compailedGetSingularTemplate(this.renderGetSingularTemplateInput(t)))
        };
        return this.compiledTemplate(input);
    }
    renderGetSingularTemplateInput(t) {
        let d = t;
        d["fields"] = this.getPrimaryKeyNames(t.tableName);
        d["params"] = this.getPkCols(t.tableName).map(col => {
            return col.field + ": " + this.typeMap.get(col.type);
        });
        return d;
    }
    renderImportRow(table, relativePath) {
        table = { ...table };
        table.filename = table.filename.replace(".ts", "");
        return `import {${table.prefixedClassName}} from "${relativePath}${table.filename}"`;
    }
}
exports.GettersBuilder = GettersBuilder;
//# sourceMappingURL=getter-builder.js.map