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

changes in model, basic template file

Browse Source
This commit is contained in:
Kononnable 2019-10-01 22:36:37 +02:00
parent a13da7848e
commit fb529bca0b
5 changed files with 138 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
src/Engine.ts
View File

@ -17,6 +17,7 @@ import AbstractNamingStrategy from "./AbstractNamingStrategy";
import changeCase = require("change-case");
import fs = require("fs");
import path = require("path");
import { Entity } from "./models/Entity";
export function createDriver(driverName: string): AbstractDriver {
switch (driverName) {
@ -43,20 +44,80 @@ export async function createModelFromDatabase(
connectionOptions: IConnectionOptions,
generationOptions: IGenerationOptions
) {
let dbModel = await dataCollectionPhase(driver, connectionOptions);
if (dbModel.length === 0) {
TomgUtils.LogError(
"Tables not found in selected database. Skipping creation of typeorm model.",
false
);
return;
}
dbModel = modelCustomizationPhase(
dbModel,
generationOptions,
driver.defaultValues
);
modelGenerationPhase(connectionOptions, generationOptions, dbModel);
// let dbModel = await dataCollectionPhase(driver, connectionOptions);
// if (dbModel.length === 0) {
// TomgUtils.LogError(
// "Tables not found in selected database. Skipping creation of typeorm model.",
// false
// );
// return;
// }
// dbModel = modelCustomizationPhase(
// dbModel,
// generationOptions,
// driver.defaultValues
// );
const dbModel: Entity = {
sqlName: "sqlName",
tscName: "typescriptName",
schema: "schema",
database: "database",
columns: [
{
tscType: "typescriptType",
tscName: "tscName",
options: {
name: "sqlName",
type: "integer",
length: 2,
scale: 2
}
},
{
tscType: "typescriptType",
tscName: "tscName",
options: {
name: "sqlName",
type: "integer",
length: 2,
scale: 2
}
}
],
indices: [
{
columns: ["columns"],
name: "name"
},
{
columns: ["columns"],
name: "name"
}
],
relations: [
{
relationType: "OneToMany",
relatedField: "relatedField",
fieldName: "relation",
relatedTable: "any",
relationOptions: {
onUpdate: "CASCADE",
onDelete: "NO ACTION"
}
},
{
relationType: "OneToOne",
relatedField: "relatedField",
fieldName: "relation",
relatedTable: "any",
relationOptions: {
onUpdate: "CASCADE",
onDelete: "NO ACTION"
}
}
]
};
modelGenerationPhase(connectionOptions, generationOptions, [dbModel]);
}
export async function dataCollectionPhase(
driver: AbstractDriver,
@ -172,7 +233,7 @@ function setRelationId(
export function modelGenerationPhase(
connectionOptions: IConnectionOptions,
generationOptions: IGenerationOptions,
databaseModel: EntityInfo[]
databaseModel: Entity[]
) {
createHandlebarsHelpers(generationOptions);
const templatePath = path.resolve(__dirname, "entity.mst");
@ -197,16 +258,16 @@ export function modelGenerationPhase(
let casedFileName = "";
switch (generationOptions.convertCaseFile) {
case "camel":
casedFileName = changeCase.camelCase(element.tsEntityName);
casedFileName = changeCase.camelCase(element.tscName);
break;
case "param":
casedFileName = changeCase.paramCase(element.tsEntityName);
casedFileName = changeCase.paramCase(element.tscName);
break;
case "pascal":
casedFileName = changeCase.pascalCase(element.tsEntityName);
casedFileName = changeCase.pascalCase(element.tscName);
break;
case "none":
casedFileName = element.tsEntityName;
casedFileName = element.tscName;
break;
default:
throw new Error("Unknown case style");
@ -221,6 +282,11 @@ export function modelGenerationPhase(
}
function createHandlebarsHelpers(generationOptions: IGenerationOptions) {
Handlebars.registerHelper("json", context => {
const json = JSON.stringify(context);
const withoutQuotes = json.replace(/"([^(")"]+)":/g, "$1:");
return withoutQuotes.slice(1, withoutQuotes.length - 1);
});
Handlebars.registerHelper("curly", open => (open ? "{" : "}"));
Handlebars.registerHelper("toEntityName", str => {
let retStr = "";

27
src/entity.mst
View File

@ -1,3 +1,30 @@
{{#*inline "Index"}}
@Index("{{name}}")
{{/inline}}
{{#*inline "Column"}}
{{#generated}}@PrimaryGeneratedColumn({ {{/generated}}{{^generated}}@Column({ {{#primary}}primary:{{primary}},{{/primary}}{{/generated}}{{json options}} })
{{tscName}}:{{tscType}};
{{/inline}}
{{#*inline "Relation"}}
@{{relationType}}(()=>{{relatedTable}},{{relatedTable}}=>{{relatedTable}}.{{relatedField}},{ {{json relationOptions}} })
{{fieldName}}:{{relatedTable}};
{{/inline}}
{{#*inline "Entity"}}
{{#indices}}{{> Index}}{{/indices~}}
@Entity("{{sqlName}}",{schema:"{{schema}}",database:"{{database}}"})
export class {{tscName}} {
{{#columns}}{{> Column}}{{/columns~}}
{{#relations}}{{> Relation}}{{/relations~}}
}
{{/inline}}
{{~> Entity}}
import {BaseEntity,Column,Entity,Index,JoinColumn,JoinTable,ManyToMany,ManyToOne,OneToMany,OneToOne,PrimaryColumn,PrimaryGeneratedColumn,RelationId} from "typeorm";
{{relationImports}}{{#each UniqueImports}}import {{curly true}}{{toEntityName this}}{{curly false}} from "./{{toFileName this}}";
{{/each}}

44
src/models/Column.ts
View File

@ -1,33 +1,23 @@
import { ColumnType } from "typeorm";
export type Column = {
tscType: any;
tscName: string;
primary?: boolean;
sqlType: ColumnType;
typescriptType: any;
name?: string;
length?: number;
width?: number;
nullable?: boolean;
generated?: true | "increment" | "uuid";
unique?: boolean;
default?: boolean;
precision?: number;
scale?: number;
unsigned?: boolean;
enum?: string[];
array?: boolean;
options: {
type: ColumnType;
name: string;
length?: number;
width?: number;
nullable?: boolean;
unique?: boolean; // ?
default?: boolean;
precision?: number;
scale?: number;
unsigned?: boolean;
enum?: string[];
array?: boolean; // ?
};
};

2
src/models/Entity.ts
View File

@ -4,7 +4,7 @@ import { Index } from "./Index";
export type Entity = {
sqlName: string;
typescriptName?: string;
tscName: string;
database?: string;
schema?: string;

23
src/models/Relation.ts
View File

@ -1,19 +1,12 @@
import { OnUpdateType } from "typeorm/metadata/types/OnUpdateType";
import { OnDeleteType } from "typeorm/metadata/types/OnDeleteType";
import { RelationType } from "typeorm/metadata/types/RelationTypes";
import { JoinTableOptions, JoinColumnOptions } from "typeorm";
import { JoinColumnOptions, RelationOptions } from "typeorm";
import { JoinTableMultipleColumnsOptions } from "typeorm/decorator/options/JoinTableMultipleColumnsOptions";
export type Relation = {
target: Function | string;
type: RelationType;
inverseSide?: string;
// lazy?: boolean;
// eager?: boolean;
// primary?: boolean;
joinTable?: boolean | JoinTableOptions | JoinTableMultipleColumnsOptions;
joinColumn?: boolean | JoinColumnOptions;
nullable?: boolean;
onDelete?: OnDeleteType;
onUpdate?: OnUpdateType;
relationType: "OneToOne" | "OneToMany" | "ManyToOne" | "ManyToMany";
relatedTable: string;
relatedField: string;
fieldName: string;
relationOptions: RelationOptions;
joinColumnOptions?: JoinColumnOptions[];
joinTableOptions?: JoinTableMultipleColumnsOptions;
};