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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const change_case = require("change-case");
const handlebars = require("handlebars");
const LINE = "let query = `CALL ${name}(${questionMarks});`;   ";
const template = `/**
 * Auto generated, do not modify!
 */
/* eslint-disable */
import * as Knex from "knex";
export default class StoredProcedures {
  constructor(private knex:Knex){

  }

  async callSp(name: string, ...args:any[]):Promise<any>{
    let questionMarks = args.map(() => "?").join(", ");
    ${LINE}
    let resp = await this.knex.raw(query,args);
    return resp[0][0];
  }
  {{#each strFunctions}}{{{this}}}{{/each}}
}
`;
const fnTemplate = `
  async {{{fnName}}}({{{typeNameList}}}):Promise<any>{
    return await this.callSp("{{{name}}}"{{{commaSepParamNames}}});
  }
`;
class SpBuilder {
    constructor(procedures, types) {
        this.procedures = procedures;
        this.types = types;
        this.compiledTemplate = handlebars.compile(template);
        this.compiledFunctionTemplate = handlebars.compile(fnTemplate);
    }
    renderTemplate() {
        const strFunctions = [];
        for (const key in this.procedures) {
            strFunctions.push(this.renderFunction(this.procedures[key]));
        }
        const input = { strFunctions: strFunctions };
        const output = this.compiledTemplate(input);
        return output;
    }
    getMySqlType(param) {
        return this.types[param.dataType];
    }
    toTsParamNotation(param) {
        return param.parameterName + ": " + this.getMySqlType(param);
    }
    renderFunction(procedure) {
        let params = [];
        for (const key in procedure.parameters) {
            params.push(procedure.parameters[key]);
        }
        params = params.filter(p => p.parameterMode === "IN");
        params.sort((a, b) => {
            return a.ordinalPosition - b.ordinalPosition;
        });
        let commaSepParamNames = params.map(p => p.parameterName).join(", ");
        if (params.length === 0) {
            commaSepParamNames = "";
        }
        else {
            commaSepParamNames = ", " + commaSepParamNames;
        }
        const typeNameList = params.map(p => this.toTsParamNotation(p)).join(", ");
        const input = {
            commaSepParamNames: commaSepParamNames,
            fnName: change_case.camelCase(procedure.name),
            name: procedure.name,
            typeNameList: typeNameList
        };
        return this.compiledFunctionTemplate(input);
    }
}
exports.default = SpBuilder;
//# sourceMappingURL=sp-builder.js.map