Abstract class generation

src/IGenerationOptions.ts

@@ -16,13 +16,16 @@ export default interface IGenerationOptions {
     propertyVisibility: "public" | "protected" | "private" | "none";
     lazy: boolean;
     activeRecord: boolean;
+    skipRelationships: boolean;
+    extendAbstractClass: string;
     generateConstructor: boolean;
     customNamingStrategyPath: string;
     relationIds: boolean;
     strictMode: "none" | "?" | "!";
     skipSchema: boolean;
     indexFile: boolean;
     exportType: "named" | "default";
+    exportAbstractClass: boolean;
 }
 
 export const eolConverter = {
@@ -42,13 +45,16 @@ export function getDefaultGenerationOptions(): IGenerationOptions {
         propertyVisibility: "none",
         lazy: false,
         activeRecord: false,
+        skipRelationships: false,
+        extendAbstractClass: "",
         generateConstructor: false,
         customNamingStrategyPath: "",
         relationIds: false,
         strictMode: "none",
         skipSchema: false,
         indexFile: false,
         exportType: "named",
+        exportAbstractClass: false,
     };
     return generationOptions;
 }

src/ModelCustomization.ts

@@ -219,9 +219,21 @@ function addImportsAndGenerationOptions(
         if (generationOptions.activeRecord) {
             entity.activeRecord = true;
         }
+        if (generationOptions.skipRelationships) {
+            entity.skipRelationships = true;
+        }
+        if (generationOptions.extendAbstractClass) {
+            entity.extendAbstractClass = generationOptions.extendAbstractClass;
+        }
         if (generationOptions.generateConstructor) {
             entity.generateConstructor = true;
         }
+        if (generationOptions.exportAbstractClass) {
+            entity.exportAbstractClass = true;
+        }
+        entity.generateSuper = !!(
+            entity.activeRecord || entity.extendAbstractClass
+        );
     });
     return dbModel;
 }

src/ModelGeneration.ts

@@ -231,7 +231,7 @@ function createHandlebarsHelpers(generationOptions: IGenerationOptions): void {
         }
     );
     Handlebars.registerHelper("defaultExport", () =>
-        generationOptions.exportType === "default" ? "default" : ""
+        generationOptions.exportType === "default" ? " default" : ""
     );
     Handlebars.registerHelper("localImport", (entityName: string) =>
         generationOptions.exportType === "default"

src/index.ts

@@ -54,6 +54,15 @@ function validateConfig(options: options): options {
             false
         );
         options.generationOptions.relationIds = false;
+    } else if (
+        options.generationOptions.activeRecord &&
+        options.generationOptions.extendAbstractClass
+    ) {
+        TomgUtils.LogError(
+            "Typeorm cannot use ActiveRecord and extend-abstract-class at the same time.",
+            false
+        );
+        options.generationOptions.activeRecord = false;
     }
     return options;
 }
@@ -238,6 +247,24 @@ function checkYargsParameters(options: options): options {
             default: options.generationOptions.activeRecord,
             describe: "Use ActiveRecord syntax for generated models",
         },
+        skipRelationships: {
+            alias: "skip-relationships",
+            boolean: true,
+            default: options.generationOptions.skipRelationships,
+            describe: "Skip relationship declarations",
+        },
+        extendAbstractClass: {
+            alias: "extend-abstract-class",
+            string: true,
+            default: options.generationOptions.extendAbstractClass,
+            describe: "Make generated models extend a custom abstract class",
+        },
+        exportAbstractClass: {
+            alias: "export-abstract-class",
+            boolean: true,
+            default: options.generationOptions.exportAbstractClass,
+            describe: "Export generated models as abstract classes",
+        },
         namingStrategy: {
             describe: "Use custom naming strategy",
             default: options.generationOptions.customNamingStrategyPath,
@@ -307,6 +334,8 @@ function checkYargsParameters(options: options): options {
     }
     options.connectionOptions.skipTables = skipTables;
     options.generationOptions.activeRecord = argv.a;
+    options.generationOptions.skipRelationships = argv.skipRelationships;
+    options.generationOptions.extendAbstractClass = argv.extendAbstractClass;
     options.generationOptions.generateConstructor = argv.generateConstructor;
     options.generationOptions.convertCaseEntity = argv.ce as IGenerationOptions["convertCaseEntity"];
     options.generationOptions.convertCaseFile = argv.cf as IGenerationOptions["convertCaseFile"];
@@ -325,7 +354,7 @@ function checkYargsParameters(options: options): options {
     options.generationOptions.exportType = argv.defaultExport
         ? "default"
         : "named";
-
+    options.generationOptions.exportAbstractClass = argv.exportAbstractClass;
     return options;
 }
 
@@ -499,6 +528,19 @@ async function useInquirer(options: options): Promise<options> {
                             value: "activeRecord",
                             checked: options.generationOptions.activeRecord,
                         },
+                        {
+                            name: "Skip relationship declarations",
+                            value: "skipRelationships",
+                            checked:
+                                options.generationOptions.skipRelationships,
+                        },
+                        {
+                            name:
+                                "Generated models extend a custom abstract class",
+                            value: "extendAbstractClass",
+                            checked:
+                                options.generationOptions.extendAbstractClass,
+                        },
                         {
                             name: "Use custom naming strategy",
                             value: "namingStrategy",
@@ -558,6 +600,12 @@ async function useInquirer(options: options): Promise<options> {
                                 options.generationOptions.exportType ===
                                 "default",
                         },
+                        {
+                            name: "Export generated models as abstract classes",
+                            value: "exportAbstractClass",
+                            checked:
+                                options.generationOptions.exportAbstractClass,
+                        },
                     ],
                     message: "Available customizations",
                     name: "selected",
@@ -601,6 +649,44 @@ async function useInquirer(options: options): Promise<options> {
         options.generationOptions.activeRecord = customizations.includes(
             "activeRecord"
         );
+        options.generationOptions.skipRelationships = customizations.includes(
+            "skipRelationships"
+        );
+        if (customizations.includes("extendAbstractClass")) {
+            const { extendAbstractClass } = await inquirer.prompt([
+                {
+                    default: options.generationOptions.extendAbstractClass,
+                    message: "Relative path to custom abstract class file:",
+                    name: "extendAbstractClass",
+                    type: "input",
+                    validate(value) {
+                        const valid = value === "" || fs.existsSync(value);
+                        return (
+                            valid ||
+                            "Please enter a valid relative path to custom abstract class file"
+                        );
+                    },
+                },
+            ]);
+
+            if (extendAbstractClass && extendAbstractClass !== "") {
+                const resultsAbsolutePath = path.join(
+                    process.cwd(),
+                    options.generationOptions.resultsPath
+                );
+                const abstractClassAbsolutePath = path.join(
+                    process.cwd(),
+                    options.generationOptions.resultsPath
+                );
+                const relativePath = path.relative(
+                    abstractClassAbsolutePath,
+                    resultsAbsolutePath
+                );
+                options.generationOptions.extendAbstractClass = relativePath;
+            } else {
+                options.generationOptions.extendAbstractClass = "";
+            }
+        }
         options.generationOptions.relationIds = customizations.includes(
             "relationId"
         );
@@ -616,6 +702,9 @@ async function useInquirer(options: options): Promise<options> {
         )
             ? "default"
             : "named";
+        options.generationOptions.exportAbstractClass = customizations.includes(
+            "exportAbstractClass"
+        );
 
         if (customizations.includes("namingStrategy")) {
             const namingStrategyPath = (

src/models/Entity.ts

@@ -17,5 +17,9 @@ export type Entity = {
     // TODO: move to sub-object or use handlebars helpers(?)
     fileImports: string[];
     activeRecord?: true;
+    skipRelationships?: boolean;
+    extendAbstractClass?: string;
+    generateSuper?: boolean;
     generateConstructor?: true;
+    exportAbstractClass?: true;
 };

src/templates/entity.mst

@@ -26,22 +26,23 @@ import {{localImport (toEntityName .)}} from './{{toFileName .}}'
 {{/inline}}
 {{#*inline "Constructor"}}
 {{printPropertyVisibility}}constructor(init?: Partial<{{toEntityName entityName}}>) {
-    {{#activeRecord}}super();
-    {{/activeRecord}}Object.assign(this, init);
+    {{#generateSuper}}super();
+    {{/generateSuper}}Object.assign(this, init);
 }
 {{/inline}}
 {{#*inline "Entity"}}
 {{#indices}}{{> Index}}{{/indices~}}
-@Entity("{{sqlName}}"{{#schema}} ,{schema:"{{.}}"{{#if ../database}}, database:"{{../database}}"{{/if}} } {{/schema}})
-export {{defaultExport}} class {{toEntityName tscName}}{{#activeRecord}} extends BaseEntity{{/activeRecord}} {
+{{#unless exportAbstractClass}}@Entity("{{sqlName}}"{{#schema}} ,{schema:"{{.}}"{{#if ../database}}, database:"{{../database}}"{{/if}} } {{/schema}}){{/unless}}
+export{{defaultExport}}{{#exportAbstractClass}} abstract{{/exportAbstractClass}} class {{toEntityName tscName}}{{#activeRecord}} extends BaseEntity{{/activeRecord}}{{#extendAbstractClass}} extends BaseClass{{/extendAbstractClass}} {
 
 {{#columns}}{{> Column}}{{/columns~}}
-{{#relations}}{{> Relation}}{{/relations~}}
+{{#unless skipRelationships}}{{#relations}}{{> Relation}}{{/relations~}}{{/unless}}
 {{#relationIds}}{{> RelationId entityName=../tscName}}{{/relationIds~}}
 {{#if generateConstructor}}{{>Constructor entityName=tscName}}{{/if~}}
 }
 {{/inline}}
 import {BaseEntity,Column,Entity,Index,JoinColumn,JoinTable,ManyToMany,ManyToOne,OneToMany,OneToOne,PrimaryColumn,PrimaryGeneratedColumn,RelationId} from "typeorm";
-{{#fileImports}}{{> Import}}{{/fileImports}}
+{{#unless skipRelationships}}{{#fileImports}}{{> Import}}{{/fileImports}}{{/unless}}
+{{#extendAbstractClass}}import BaseClass from "{{.}}";{{/extendAbstractClass}}
 
 {{> Entity}}

test/modelCustomization/modelCustomization.test.ts

@@ -451,6 +451,118 @@ describe("Model customization phase", async () => {
 
         compileGeneratedModel(generationOptions.resultsPath, [""]);
     });
+    it("skipRelationships", async () => {
+        const data = generateSampleData();
+        const generationOptions = generateGenerationOptions();
+        clearGenerationDir();
+
+        generationOptions.skipRelationships = true;
+        const customizedModel = modelCustomizationPhase(
+            data,
+            generationOptions,
+            {}
+        );
+        modelGenerationPhase(
+            getDefaultConnectionOptions(),
+            generationOptions,
+            customizedModel
+        );
+        const filesGenPath = path.resolve(resultsPath, "entities");
+        const postContent = fs
+            .readFileSync(path.resolve(filesGenPath, "Post.ts"))
+            .toString();
+        const postAuthorContent = fs
+            .readFileSync(path.resolve(filesGenPath, "PostAuthor.ts"))
+            .toString();
+        expect(postContent).to.not.have.string(
+            `JoinColumn`,
+        );
+        expect(postContent).to.not.have.string(
+            `import { PostAuthor } from "./PostAuthor";`,
+        );
+        expect(postAuthorContent).to.not.have.string(
+            `OneToMany`,
+        );
+        expect(postAuthorContent).to.not.have.string(
+            `import { Post } from "./Post";`,
+        );
+
+        compileGeneratedModel(generationOptions.resultsPath, [""]);
+    });
+    it("extendAbstractClass", async () => {
+        const data = generateSampleData();
+        const generationOptions = generateGenerationOptions();
+        clearGenerationDir();
+
+        generationOptions.extendAbstractClass = '../../test/integration/examples/sample28-abstract-class-inheritance/BaseClass';
+        const customizedModel = modelCustomizationPhase(
+            data,
+            generationOptions,
+            {}
+        );
+        modelGenerationPhase(
+            getDefaultConnectionOptions(),
+            generationOptions,
+            customizedModel
+        );
+        const filesGenPath = path.resolve(resultsPath, "entities");
+        const postContent = fs
+            .readFileSync(path.resolve(filesGenPath, "Post.ts"))
+            .toString();
+        const postAuthorContent = fs
+            .readFileSync(path.resolve(filesGenPath, "PostAuthor.ts"))
+            .toString();
+        expect(postContent).to.have.string(
+            `export class Post extends BaseClass `
+        );
+        expect(postAuthorContent).to.have.string(
+            `export class PostAuthor extends BaseClass `
+        );
+        expect(postContent).to.have.string(
+            `import BaseClass from "../../test/integration/examples/sample28-abstract-class-inheritance/BaseClass"`
+        );
+        expect(postAuthorContent).to.have.string(
+            `import BaseClass from "../../test/integration/examples/sample28-abstract-class-inheritance/BaseClass"`
+        );
+    });
+    it("exportAbstractClass", async () => {
+        const data = generateSampleData();
+        const generationOptions = generateGenerationOptions();
+        clearGenerationDir();
+
+        generationOptions.exportAbstractClass = true;
+        const customizedModel = modelCustomizationPhase(
+            data,
+            generationOptions,
+            {}
+        );
+        modelGenerationPhase(
+            getDefaultConnectionOptions(),
+            generationOptions,
+            customizedModel
+        );
+        const filesGenPath = path.resolve(resultsPath, "entities");
+        const postContent = fs
+            .readFileSync(path.resolve(filesGenPath, "Post.ts"))
+            .toString();
+        const postAuthorContent = fs
+            .readFileSync(path.resolve(filesGenPath, "PostAuthor.ts"))
+            .toString();
+        expect(postContent).to.have.string(
+            `export abstract class Post `
+        );
+        expect(postAuthorContent).to.have.string(
+            `export abstract class PostAuthor `
+        );
+        expect(postContent).to.not.have.string(
+            `@Entity`
+        );
+        expect(postAuthorContent).to.not.have.string(
+            `@Entity`
+        );
+
+        compileGeneratedModel(generationOptions.resultsPath, [""]);
+    });
     it("skipSchema", async () => {
         const data = generateSampleData();
         const generationOptions = generateGenerationOptions();