f.spilla/typeorm-model-generator
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

support for more(all?) column types in MSSQL

Browse Source
This commit is contained in:
Kononnable 2017-11-19 22:38:04 +01:00
parent 354212bc8d
commit 298c3bc415
7 changed files with 497 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/drivers/MssqlDriver.ts
View File

@ -21,7 +21,7 @@ export class MssqlDriver extends AbstractDriver {
});
}
async GetAllTables(schema:string): Promise<EntityInfo[]> {
async GetAllTables(schema: string): Promise<EntityInfo[]> {
let request = new MSSQL.Request(this.Connection)
let response: { TABLE_SCHEMA: string, TABLE_NAME: string }[]
= (await request.query(`SELECT TABLE_SCHEMA,TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE' and TABLE_SCHEMA='${schema}'`)).recordset;
@ -35,7 +35,7 @@ export class MssqlDriver extends AbstractDriver {
})
return ret;
}
async GetCoulmnsFromEntity(entities: EntityInfo[],schema:string): Promise<EntityInfo[]> {
async GetCoulmnsFromEntity(entities: EntityInfo[], schema: string): Promise<EntityInfo[]> {
let request = new MSSQL.Request(this.Connection)
let response: {
TABLE_NAME: string, COLUMN_NAME: string, COLUMN_DEFAULT: string,
@ -78,9 +78,10 @@ export class MssqlDriver extends AbstractDriver {
colInfo.ts_type = "number"
colInfo.sql_type = "float"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
colInfo.numericPrecision = resp.NUMERIC_PRECISION
break;
case "bigint":
colInfo.ts_type = "number"
colInfo.ts_type = "string"
colInfo.sql_type = "bigint"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
@ -98,12 +99,12 @@ export class MssqlDriver extends AbstractDriver {
break;
case "char":
colInfo.ts_type = "string"
colInfo.sql_type = "text"
colInfo.sql_type = "char"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "nchar":
colInfo.ts_type = "string"
colInfo.sql_type = "text"
colInfo.sql_type = "nchar"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "text":
@ -112,13 +113,31 @@ export class MssqlDriver extends AbstractDriver {
break;
case "ntext":
colInfo.ts_type = "string"
colInfo.sql_type = "text"
colInfo.sql_type = "ntext"
break;
case "uniqueidentifier":
colInfo.ts_type = "string"
colInfo.sql_type = "uniqueidentifier"
break;
case "varchar":
colInfo.ts_type = "string"
colInfo.sql_type = "varchar"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "binary":
colInfo.ts_type = "Buffer"
colInfo.sql_type = "binary"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "varbinary":
colInfo.ts_type = "Buffer"
colInfo.sql_type = "varbinary"
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "image":
colInfo.ts_type = "Buffer"
colInfo.sql_type = "image"
break;
case "nvarchar":
colInfo.ts_type = "string"
colInfo.sql_type = "nvarchar"
@ -128,6 +147,10 @@ export class MssqlDriver extends AbstractDriver {
colInfo.ts_type = "number"
colInfo.sql_type = "decimal"
break;
case "smallmoney":
colInfo.ts_type = "number"
colInfo.sql_type = "smallmoney"
break;
case "real":
colInfo.ts_type = "number"
colInfo.sql_type = "double"
@ -140,6 +163,32 @@ export class MssqlDriver extends AbstractDriver {
colInfo.numericScale = resp.NUMERIC_SCALE
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "numeric":
colInfo.ts_type = "number"
colInfo.sql_type = "numeric"
colInfo.numericPrecision = resp.NUMERIC_PRECISION
colInfo.numericScale = resp.NUMERIC_SCALE
colInfo.char_max_lenght = resp.CHARACTER_MAXIMUM_LENGTH > 0 ? resp.CHARACTER_MAXIMUM_LENGTH : null;
break;
case "datetime2":
colInfo.ts_type = "Date"
colInfo.sql_type = "datetime2"
colInfo.numericPrecision = resp.NUMERIC_PRECISION
break;
case "time":
colInfo.ts_type = "Date"
colInfo.sql_type = "time"
colInfo.numericPrecision = resp.NUMERIC_PRECISION
break;
case "datetimeoffset":
colInfo.ts_type = "Date"
colInfo.sql_type = "datetimeoffset"
colInfo.numericPrecision = resp.NUMERIC_PRECISION
break;
case "smalldatetime":
colInfo.ts_type = "Date"
colInfo.sql_type = "smalldatetime"
break;
case "xml":
colInfo.ts_type = "string"
colInfo.sql_type = "text"
@ -148,13 +197,13 @@ export class MssqlDriver extends AbstractDriver {
console.error("Unknown column type:" + resp.DATA_TYPE);
break;
}
if (colInfo.sql_type) ent.Columns.push(colInfo);
})
})
return entities;
}
async GetIndexesFromEntity(entities: EntityInfo[],schema:string): Promise<EntityInfo[]> {
async GetIndexesFromEntity(entities: EntityInfo[], schema: string): Promise<EntityInfo[]> {
let request = new MSSQL.Request(this.Connection)
let response: {
TableName: string, IndexName: string, ColumnName: string, is_unique: number,
@ -211,7 +260,7 @@ ORDER BY
return entities;
}
async GetRelations(entities: EntityInfo[],schema:string): Promise<EntityInfo[]> {
async GetRelations(entities: EntityInfo[], schema: string): Promise<EntityInfo[]> {
let request = new MSSQL.Request(this.Connection)
let response: {
TableWithForeignKey: string, FK_PartNo: number, ForeignKeyColumn: string,
@ -358,7 +407,7 @@ order by
}
private Connection: MSSQL.ConnectionPool;
async ConnectToServer(database: string, server: string, port: number, user: string, password: string,ssl:boolean) {
async ConnectToServer(database: string, server: string, port: number, user: string, password: string, ssl: boolean) {
let config: MSSQL.config = {
database: database,
server: server,

2
src/models/ColumnInfo.ts
View File

@ -7,7 +7,7 @@ export class ColumnInfo {
name: string = '';
default: string | null = null;
is_nullable: boolean = false;
ts_type: 'number' | 'string' | 'boolean' | 'Date' | 'any';
ts_type: 'number' | 'string' | 'boolean' | 'Date' | 'Buffer' | 'any';
sql_type: ColumnType;
char_max_lenght: number | null = null;
isPrimary: boolean = false;

99
test/integration/entityTypes.test.ts Normal file
View File

@ -0,0 +1,99 @@
require('dotenv').config()
import "reflect-metadata";
import { createConnection, ConnectionOptions, Connection } from "typeorm";
import fs = require('fs-extra');
import path = require('path')
import { expect } from "chai";
import * as Sinon from 'sinon'
import { EntityFileToJson } from "../utils/EntityFileToJson";
var chai = require('chai');
var chaiSubset = require('chai-subset');
import * as ts from "typescript";
import * as GTU from "../utils/GeneralTestUtils"
import { Engine } from "./../../src/Engine";
chai.use(chaiSubset);
describe("platform specyfic types", async function () {
this.timeout(20000)
this.slow(5000)//compiling created models takes time
let examplesPathJS = path.resolve(process.cwd(), 'dist/test/integration/entityTypes')
let examplesPathTS = path.resolve(process.cwd(), 'test/integration/entityTypes')
let files = fs.readdirSync(examplesPathTS)
let dbDrivers: string[] = []
if (process.env.POSTGRES_Skip == '0') dbDrivers.push('postgres')
if (process.env.MYSQL_Skip == '0') dbDrivers.push('mysql')
if (process.env.MARIADB_Skip == '0') dbDrivers.push('mariadb')
if (process.env.MSSQL_Skip == '0') dbDrivers.push('mssql')
for (let folder of files) {
describe(folder, async function () {
for (let dbDriver of dbDrivers) {
if (dbDriver == folder) {
it(dbDriver, async function () {
let filesOrgPathJS = path.resolve(examplesPathJS, folder, 'entity')
let filesOrgPathTS = path.resolve(examplesPathTS, folder, 'entity')
let resultsPath = path.resolve(process.cwd(), `output`)
fs.removeSync(resultsPath)
let engine: Engine;
switch (dbDriver) {
case 'mssql':
engine = await GTU.createMSSQLModels(filesOrgPathJS, resultsPath)
break;
case 'postgres':
engine = await GTU.createPostgresModels(filesOrgPathJS, resultsPath)
break;
case 'mysql':
engine = await GTU.createMysqlModels(filesOrgPathJS, resultsPath)
break;
case 'mariadb':
engine = await GTU.createMariaDBModels(filesOrgPathJS, resultsPath)
break;
default:
console.log(`Unknown engine type`);
engine = <Engine>{}
break;
}
let result = await engine.createModelFromDatabase()
let filesGenPath = path.resolve(resultsPath, 'entities')
let filesOrg = fs.readdirSync(filesOrgPathTS).filter(function (this, val, ind, arr) { return val.toString().endsWith('.ts') })
let filesGen = fs.readdirSync(filesGenPath).filter(function (this, val, ind, arr) { return val.toString().endsWith('.ts') })
expect(filesOrg, 'Errors detected in model comparision').to.be.deep.equal(filesGen)
for (let file of filesOrg) {
let entftj = new EntityFileToJson();
let jsonEntityOrg = entftj.convert(fs.readFileSync(path.resolve(filesOrgPathTS, file)))
let jsonEntityGen = entftj.convert(fs.readFileSync(path.resolve(filesGenPath, file)))
expect(jsonEntityGen, `Error in file ${file}`).to.containSubset(jsonEntityOrg)
}
const currentDirectoryFiles = fs.readdirSync(filesGenPath).
filter(fileName => fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts").map(v => {
return path.resolve(filesGenPath, v)
})
let compileErrors = GTU.compileTsFiles(currentDirectoryFiles, {
experimentalDecorators: true,
sourceMap: false,
emitDecoratorMetadata: true,
target: ts.ScriptTarget.ES2016,
moduleResolution: ts.ModuleResolutionKind.NodeJs,
module: ts.ModuleKind.CommonJS
});
expect(compileErrors, 'Errors detected while compiling generated model').to.be.false;
});
}
}
})
}
})

121
test/integration/entityTypes/mssql/entity/Post.ts Normal file
View File

@ -0,0 +1,121 @@
import { Entity, PrimaryColumn, Column } from "typeorm";
@Entity("Post")
export class Post {
@PrimaryColumn()
id: number;
@Column()
name: string;
// -------------------------------------------------------------------------
// Numeric Types
// -------------------------------------------------------------------------
@Column("bit")
bit: boolean;
@Column("tinyint")
tinyint: number;
@Column("smallint")
smallint: number;
@Column("int")
int: number;
@Column("bigint")
bigint: string;
@Column("decimal")
decimal: number;
@Column("dec")
dec: number;
@Column("numeric")
numeric: number;
@Column("float")
float: number;
@Column("real")
real: number;
@Column("smallmoney")
smallmoney: number;
@Column("money")
money: number;
// -------------------------------------------------------------------------
// Character Types
// -------------------------------------------------------------------------
@Column("uniqueidentifier")
uniqueidentifier: string;
@Column("char")
char: string;
@Column("varchar")
varchar: string;
@Column("text")
text: string;
@Column("nchar")
nchar: string;
@Column("nvarchar")
nvarchar: string;
@Column("ntext")
ntext: string;
@Column("binary")
binary: Buffer;
@Column("varbinary")
varbinary: Buffer;
@Column("image")
image: Buffer;
// -------------------------------------------------------------------------
// Date Types
// -------------------------------------------------------------------------
@Column("date")
dateObj: Date;
// @Column("date")
// date: string;
@Column("datetime")
datetime: Date;
@Column("datetime2")
datetime2: Date;
@Column("smalldatetime")
smalldatetime: Date;
@Column("time")
timeObj: Date;
// @Column("time")
// time: string;
@Column("datetimeoffset")
datetimeoffset: Date;
// -------------------------------------------------------------------------
// TypeOrm Specific Type
// -------------------------------------------------------------------------
// @Column("simple-array")
// simpleArray: string[];
}

6
test/integration/examples/sample11-all-types-entity/entity/EverythingEntity.ts
View File

@ -2,7 +2,7 @@ import { PrimaryGeneratedColumn, Column, Entity, OneToOne, JoinColumn, Index } f
@Entity("EverythingEntity")
export class EverythingEntity {
//TODO: change to check column types per database engine
//TODO: change to check column types per database engine
@PrimaryGeneratedColumn()
id: number;
@ -27,8 +27,8 @@ export class EverythingEntity {
@Column("smallint")
smallintColumn: number;
@Column("bigint")
bigintColumn: number;
// @Column("bigint")
// bigintColumn: number;
// @Column("float")
// floatColumn: number;

214
test/integration/integration.test.ts
View File

@ -4,23 +4,19 @@ import { createConnection, ConnectionOptions, Connection } from "typeorm";
import fs = require('fs-extra');
import path = require('path')
import { Engine } from "./../../src/Engine";
import { AbstractDriver } from "./../../src/drivers/AbstractDriver";
import { MssqlDriver } from "./../../src/drivers/MssqlDriver";
import { expect } from "chai";
import * as Sinon from 'sinon'
import { EntityFileToJson } from "../utils/EntityFileToJson";
var chai = require('chai');
var chaiSubset = require('chai-subset');
import * as ts from "typescript";
import { PostgresDriver } from "../../src/drivers/PostgresDriver";
import { MysqlDriver } from "../../src/drivers/MysqlDriver";
import { MariaDbDriver } from "../../src/drivers/MariaDbDriver";
import * as yn from "yn"
import * as ts from "typescript";
import * as GTU from "../utils/GeneralTestUtils"
chai.use(chaiSubset);
describe("integration tests", async function () {
describe("integration tests - examples", async function () {
this.timeout(20000)
this.slow(5000)//compiling created models takes time
let examplesPathJS = path.resolve(process.cwd(), 'dist/test/integration/examples')
@ -47,16 +43,16 @@ describe("integration tests", async function () {
let engine: Engine;
switch (dbDriver) {
case 'mssql':
engine = await createMSSQLModels(filesOrgPathJS, resultsPath)
engine = await GTU.createMSSQLModels(filesOrgPathJS, resultsPath)
break;
case 'postgres':
engine = await createPostgresModels(filesOrgPathJS, resultsPath)
engine = await GTU.createPostgresModels(filesOrgPathJS, resultsPath)
break;
case 'mysql':
engine = await createMysqlModels(filesOrgPathJS, resultsPath)
engine = await GTU.createMysqlModels(filesOrgPathJS, resultsPath)
break;
case 'mariadb':
engine = await createMariaDBModels(filesOrgPathJS, resultsPath)
engine = await GTU.createMariaDBModels(filesOrgPathJS, resultsPath)
break;
default:
@ -85,7 +81,7 @@ describe("integration tests", async function () {
filter(fileName => fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts").map(v => {
return path.resolve(filesGenPath, v)
})
let compileErrors = compileTsFiles(currentDirectoryFiles, {
let compileErrors = GTU.compileTsFiles(currentDirectoryFiles, {
experimentalDecorators: true,
sourceMap: false,
@ -101,197 +97,3 @@ describe("integration tests", async function () {
})
}
})
async function createMSSQLModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MssqlDriver();
await driver.ConnectToServer(`master`, String(process.env.MSSQL_Host), Number(process.env.MSSQL_Port), String(process.env.MSSQL_Username), String(process.env.MSSQL_Password), yn(process.env.MSSQL_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MSSQL_Database)))
await driver.CreateDB(String(process.env.MSSQL_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MSSQL_Database),
host: String(process.env.MSSQL_Host),
password: String(process.env.MSSQL_Password),
type: 'mssql',
username: String(process.env.MSSQL_Username),
port: Number(process.env.MSSQL_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MssqlDriver();
let engine = new Engine(
driver, {
host: String(process.env.MSSQL_Host),
port: Number(process.env.MSSQL_Port),
databaseName: String(process.env.MSSQL_Database),
user: String(process.env.MSSQL_Username),
password: String(process.env.MSSQL_Password),
databaseType: 'mssql',
resultsPath: resultsPath,
schemaName:'dbo',
ssl:yn(process.env.MSSQL_SSL)
});
return engine;
}
async function createPostgresModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new PostgresDriver();
await driver.ConnectToServer(`postgres`, String(process.env.POSTGRES_Host), Number(process.env.POSTGRES_Port), String(process.env.POSTGRES_Username), String(process.env.POSTGRES_Password),yn(process.env.POSTGRES_SSL));
if (! await driver.CheckIfDBExists(String(process.env.POSTGRES_Database)))
await driver.CreateDB(String(process.env.POSTGRES_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.POSTGRES_Database),
host: String(process.env.POSTGRES_Host),
password: String(process.env.POSTGRES_Password),
type: 'postgres',
username: String(process.env.POSTGRES_Username),
port: Number(process.env.POSTGRES_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new PostgresDriver();
let engine = new Engine(
driver, {
host: String(process.env.POSTGRES_Host),
port: Number(process.env.POSTGRES_Port),
databaseName: String(process.env.POSTGRES_Database),
user: String(process.env.POSTGRES_Username),
password: String(process.env.POSTGRES_Password),
databaseType: 'postgres',
resultsPath: resultsPath,
schemaName:'public',
ssl:yn(process.env.POSTGRES_SSL)
});
return engine;
}
async function createMysqlModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MysqlDriver();
await driver.ConnectToServer(`mysql`, String(process.env.MYSQL_Host), Number(process.env.MYSQL_Port), String(process.env.MYSQL_Username), String(process.env.MYSQL_Password),yn(process.env.MYSQL_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MYSQL_Database)))
await driver.CreateDB(String(process.env.MYSQL_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MYSQL_Database),
host: String(process.env.MYSQL_Host),
password: String(process.env.MYSQL_Password),
type: 'mysql',
username: String(process.env.MYSQL_Username),
port: Number(process.env.MYSQL_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MysqlDriver();
let engine = new Engine(
driver, {
host: String(process.env.MYSQL_Host),
port: Number(process.env.MYSQL_Port),
databaseName: String(process.env.MYSQL_Database),
user: String(process.env.MYSQL_Username),
password: String(process.env.MYSQL_Password),
databaseType: 'mysql',
resultsPath: resultsPath,
schemaName:'ignored',
ssl:yn(process.env.MYSQL_SSL)
});
return engine;
}
async function createMariaDBModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MariaDbDriver();
await driver.ConnectToServer(`mysql`, String(process.env.MARIADB_Host), Number(process.env.MARIADB_Port), String(process.env.MARIADB_Username), String(process.env.MARIADB_Password),yn(process.env.MARIADB_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MARIADB_Database)))
await driver.CreateDB(String(process.env.MARIADB_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MARIADB_Database),
host: String(process.env.MARIADB_Host),
password: String(process.env.MARIADB_Password),
type: 'mariadb',
username: String(process.env.MARIADB_Username),
port: Number(process.env.MARIADB_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MariaDbDriver();
let engine = new Engine(
driver, {
host: String(process.env.MARIADB_Host),
port: Number(process.env.MARIADB_Port),
databaseName: String(process.env.MARIADB_Database),
user: String(process.env.MARIADB_Username),
password: String(process.env.MARIADB_Password),
databaseType: 'mariadb',
resultsPath: resultsPath,
schemaName:'ignored',
ssl:yn(process.env.MARIADB_SSL)
});
return engine;
}
function compileTsFiles(fileNames: string[], options: ts.CompilerOptions): boolean {
let program = ts.createProgram(fileNames, options);
let emitResult = program.emit();
let compileErrors = false;
let allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
allDiagnostics.forEach(diagnostic => {
let lineAndCharacter = diagnostic.file!.getLineAndCharacterOfPosition(diagnostic.start!);
let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
console.log(`${diagnostic.file!.fileName} (${lineAndCharacter.line + 1},${lineAndCharacter.character + 1}): ${message}`);
compileErrors = true;
});
return compileErrors;
}

206
test/utils/GeneralTestUtils.ts Normal file
View File

@ -0,0 +1,206 @@
import * as ts from "typescript";
import { AbstractDriver } from "../../src/drivers/AbstractDriver";
import { MssqlDriver } from "../../src/drivers/MssqlDriver";
import { PostgresDriver } from "./../../src/drivers/PostgresDriver";
import { MysqlDriver } from "../../src/drivers/MysqlDriver";
import { MariaDbDriver } from "../../src/drivers/MariaDbDriver";
import { Engine } from "../../src/Engine";
import { createConnection, ConnectionOptions, Connection } from "typeorm";
import * as yn from "yn"
import path = require('path')
export async function createMSSQLModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MssqlDriver();
await driver.ConnectToServer(`master`, String(process.env.MSSQL_Host), Number(process.env.MSSQL_Port), String(process.env.MSSQL_Username), String(process.env.MSSQL_Password), yn(process.env.MSSQL_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MSSQL_Database)))
await driver.CreateDB(String(process.env.MSSQL_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MSSQL_Database),
host: String(process.env.MSSQL_Host),
password: String(process.env.MSSQL_Password),
type: 'mssql',
username: String(process.env.MSSQL_Username),
port: Number(process.env.MSSQL_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MssqlDriver();
let engine = new Engine(
driver, {
host: String(process.env.MSSQL_Host),
port: Number(process.env.MSSQL_Port),
databaseName: String(process.env.MSSQL_Database),
user: String(process.env.MSSQL_Username),
password: String(process.env.MSSQL_Password),
databaseType: 'mssql',
resultsPath: resultsPath,
schemaName: 'dbo',
ssl: yn(process.env.MSSQL_SSL)
});
return engine;
}
export async function createPostgresModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new PostgresDriver();
await driver.ConnectToServer(`postgres`, String(process.env.POSTGRES_Host), Number(process.env.POSTGRES_Port), String(process.env.POSTGRES_Username), String(process.env.POSTGRES_Password), yn(process.env.POSTGRES_SSL));
if (! await driver.CheckIfDBExists(String(process.env.POSTGRES_Database)))
await driver.CreateDB(String(process.env.POSTGRES_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.POSTGRES_Database),
host: String(process.env.POSTGRES_Host),
password: String(process.env.POSTGRES_Password),
type: 'postgres',
username: String(process.env.POSTGRES_Username),
port: Number(process.env.POSTGRES_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new PostgresDriver();
let engine = new Engine(
driver, {
host: String(process.env.POSTGRES_Host),
port: Number(process.env.POSTGRES_Port),
databaseName: String(process.env.POSTGRES_Database),
user: String(process.env.POSTGRES_Username),
password: String(process.env.POSTGRES_Password),
databaseType: 'postgres',
resultsPath: resultsPath,
schemaName: 'public',
ssl: yn(process.env.POSTGRES_SSL)
});
return engine;
}
export async function createMysqlModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MysqlDriver();
await driver.ConnectToServer(`mysql`, String(process.env.MYSQL_Host), Number(process.env.MYSQL_Port), String(process.env.MYSQL_Username), String(process.env.MYSQL_Password), yn(process.env.MYSQL_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MYSQL_Database)))
await driver.CreateDB(String(process.env.MYSQL_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MYSQL_Database),
host: String(process.env.MYSQL_Host),
password: String(process.env.MYSQL_Password),
type: 'mysql',
username: String(process.env.MYSQL_Username),
port: Number(process.env.MYSQL_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MysqlDriver();
let engine = new Engine(
driver, {
host: String(process.env.MYSQL_Host),
port: Number(process.env.MYSQL_Port),
databaseName: String(process.env.MYSQL_Database),
user: String(process.env.MYSQL_Username),
password: String(process.env.MYSQL_Password),
databaseType: 'mysql',
resultsPath: resultsPath,
schemaName: 'ignored',
ssl: yn(process.env.MYSQL_SSL)
});
return engine;
}
export async function createMariaDBModels(filesOrgPath: string, resultsPath: string): Promise<Engine> {
let driver: AbstractDriver;
driver = new MariaDbDriver();
await driver.ConnectToServer(`mysql`, String(process.env.MARIADB_Host), Number(process.env.MARIADB_Port), String(process.env.MARIADB_Username), String(process.env.MARIADB_Password), yn(process.env.MARIADB_SSL));
if (! await driver.CheckIfDBExists(String(process.env.MARIADB_Database)))
await driver.CreateDB(String(process.env.MARIADB_Database));
await driver.DisconnectFromServer();
let connOpt: ConnectionOptions = {
database: String(process.env.MARIADB_Database),
host: String(process.env.MARIADB_Host),
password: String(process.env.MARIADB_Password),
type: 'mariadb',
username: String(process.env.MARIADB_Username),
port: Number(process.env.MARIADB_Port),
dropSchema: true,
synchronize: true,
entities: [path.resolve(filesOrgPath, '*.js')],
}
let conn = await createConnection(connOpt)
if (conn.isConnected)
await conn.close()
driver = new MariaDbDriver();
let engine = new Engine(
driver, {
host: String(process.env.MARIADB_Host),
port: Number(process.env.MARIADB_Port),
databaseName: String(process.env.MARIADB_Database),
user: String(process.env.MARIADB_Username),
password: String(process.env.MARIADB_Password),
databaseType: 'mariadb',
resultsPath: resultsPath,
schemaName: 'ignored',
ssl: yn(process.env.MARIADB_SSL)
});
return engine;
}
export function compileTsFiles(fileNames: string[], options: ts.CompilerOptions): boolean {
let program = ts.createProgram(fileNames, options);
let emitResult = program.emit();
let compileErrors = false;
let preDiagnostics = ts.getPreEmitDiagnostics(program);
let allDiagnostics = [...preDiagnostics, ...emitResult.diagnostics];
allDiagnostics.forEach(diagnostic => {
let lineAndCharacter = diagnostic.file!.getLineAndCharacterOfPosition(diagnostic.start!);
let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
console.log(`${diagnostic.file!.fileName} (${lineAndCharacter.line + 1},${lineAndCharacter.character + 1}): ${message}`);
compileErrors = true;
});
return compileErrors;
}