initial commit

Author: Umed Khudoiberdiev

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+build/

README.md

@@ -0,0 +1 @@
+# TypeDI Service container integration with TypeORM

package.json

@@ -0,0 +1,36 @@
+{
+  "name": "typeorm-typedi-extensions",
+  "version": "0.0.1",
+  "description": "Dependancy injection and service container integration with TypeORM using typedi library.",
+  "license": "MIT",
+  "readmeFilename": "README.md",
+  "author": {
+    "name": "Umed Khudoiberdiev",
+    "email": "[email protected]"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/typeorm/typeorm-typedi-extensions.git"
+  },
+  "bugs": {
+    "url": "https://github.com/typeorm/typeorm-typedi-extensions/issues"
+  },
+  "tags": [
+    "orm",
+    "typescript",
+    "typescript-orm",
+    "typeorm-typedi-extensions",
+    "typeorm-typedi"
+  ],
+  "devDependencies": {
+    "pg": "^6.1.0",
+    "reflect-metadata": "^0.1.8",
+    "typedi": "^0.4.2",
+    "typeorm": "^0.0.2-alpha.62",
+    "typescript": "^2.0.2"
+  },
+  "peerDependencies": {
+    "typeorm": "^0.0.2-alpha.62",
+    "typedi": "^0.4.2"
+  }
+}

sample/sample1-simple-usage/app.ts

@@ -0,0 +1,43 @@
+import "reflect-metadata";
+import {createConnection, useContainer} from "typeorm";
+import {Container} from "typedi";
+import {PostRepository} from "./repository/PostRepository";
+import {Post} from "./entity/Post";
+
+useContainer(Container);
+createConnection({
+    driver: {
+        type: "postgres",
+        host: "localhost",
+        port: 5432,
+        username: "test",
+        password: "admin",
+        database: "test"
+    },
+    entities: [
+        __dirname + "/entity/*.js"
+    ],
+    autoSchemaSync: true
+}).then(async connection => {
+    console.log("connected");
+
+    const post1 = new Post();
+    post1.title = "TypeScript 2.0";
+    post1.text = `New TypeScript version adds control flow based type analysis features.`;
+
+    const post2 = new Post();
+    post2.title = "Control flow based type analysis";
+    post2.text = `TypeScript 2.0 implements a control flow-based type analysis for local variables and parameters.`;
+
+    const repository = Container.get(PostRepository);
+    await Promise.all([
+        repository.saveUsingRepository(post1),
+        repository.saveUsingManager(post2)
+    ]);
+
+    console.log("Saved successfully.");
+
+    const loadedPosts = await repository.findAll();
+    console.log("All loaded posts: ", loadedPosts);
+
+}).catch(error => console.log("Error: ", error));

sample/sample1-simple-usage/entity/Post.ts

@@ -0,0 +1,15 @@
+import {Table, PrimaryColumn, Column} from "typeorm";
+
+@Table()
+export class Post {
+
+    @PrimaryColumn("int", { generated: true })
+    id: number;
+
+    @Column()
+    title: string;
+
+    @Column()
+    text: string;
+
+}

sample/sample1-simple-usage/repository/PostRepository.ts

@@ -0,0 +1,28 @@
+import {Repository, EntityManager} from "typeorm";
+import {Service} from "typedi";
+import {Post} from "../entity/Post";
+import {OrmRepository} from "../../../src/decorators/OrmRepository";
+import {OrmEntityManager} from "../../../src/decorators/OrmEntityManager";
+
+@Service()
+export class PostRepository {
+
+    @OrmEntityManager()
+    private entityManager: EntityManager;
+
+    constructor(@OrmRepository(Post) private ormRepository: Repository<Post>) {
+    }
+
+    saveUsingRepository(post: Post) {
+        return this.ormRepository.persist(post);
+    }
+
+    saveUsingManager(post: Post) {
+        return this.entityManager.persist(post);
+    }
+
+    findAll() {
+        return this.ormRepository.find();
+    }
+
+}

src/decorators/OrmEntityManager.ts

@@ -0,0 +1,32 @@
+import {ConnectionManager} from "typeorm";
+import {Container} from "typedi";
+
+/**
+ * Allows to inject an EntityManager using typedi's Container.
+ */
+export function OrmEntityManager(connectionName: string = "default"): Function {
+    return function(target: Object|Function, propertyName: string, index?: number) {
+
+        const getValue = () => {
+            const connectionManager = Container.get(ConnectionManager);
+            if (!connectionManager.has(connectionName))
+                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
+                `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+                `in your application before you established a connection and importing any entity.`);
+
+            const connection = connectionManager.get(connectionName);
+            const entityManager = connection.entityManager;
+            if (!entityManager)
+                throw new Error(`Entity manager was not found on "${connectionName}" connection. ` +
+                    `Make sure you correctly setup connection and container usage.`);
+
+            return entityManager;
+        };
+
+        if (index !== undefined) {
+            Container.registerParamHandler({ type: target as Function, index: index, getValue: getValue });
+        } else {
+            Container.registerPropertyHandler({ target: target as Function /* todo: looks like typedi wrong type here */, key: propertyName, getValue: getValue });
+        }
+    };
+}

src/decorators/OrmRepository.ts

@@ -0,0 +1,27 @@
+import {ConnectionManager} from "typeorm";
+import {Container} from "typedi";
+
+/**
+ * Allows to inject a Repository using typedi's Container.
+ */
+export function OrmRepository(cls: Function, connectionName: string = "default"): Function {
+    return function(target: Object|Function, propertyName: string, index?: number) {
+
+        const getValue = () => {
+            const connectionManager = Container.get(ConnectionManager);
+            if (!connectionManager.has(connectionName))
+                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
+                    `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+                    `in your application before you established a connection and importing any entity.`);
+
+            const connection = connectionManager.get(connectionName);
+            return connection.getRepository(cls as any);
+        };
+
+        if (index !== undefined) {
+            Container.registerParamHandler({ type: target as Function, index: index, getValue: getValue });
+        } else {
+            Container.registerPropertyHandler({ target: target as Function /* todo: looks like typedi wrong type here */, key: propertyName, getValue: getValue });
+        }
+    };
+}

src/decorators/OrmSpecificRepository.ts

@@ -0,0 +1,27 @@
+import {ConnectionManager} from "typeorm";
+import {Container} from "typedi";
+
+/**
+ * Allows to inject a SpecificRepository using typedi's Container.
+ */
+export function OrmSpecificRepository(cls: Function, connectionName: string = "default"): Function {
+    return function(target: Object|Function, propertyName: string, index?: number) {
+
+        const getValue = () => {
+            const connectionManager = Container.get(ConnectionManager);
+            if (!connectionManager.has(connectionName))
+                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
+                    `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+                    `in your application before you established a connection and importing any entity.`);
+
+            const connection = connectionManager.get(connectionName);
+            return connection.getSpecificRepository(cls as any);
+        };
+
+        if (index !== undefined) {
+            Container.registerParamHandler({ type: target as Function, index: index, getValue: getValue });
+        } else {
+            Container.registerPropertyHandler({ target: target as Function /* todo: looks like typedi wrong type here */, key: propertyName, getValue: getValue });
+        }
+    };
+}

src/decorators/OrmTreeRepository.ts

@@ -0,0 +1,27 @@
+import {ConnectionManager} from "typeorm";
+import {Container} from "typedi";
+
+/**
+ * Allows to inject a TreeRepository using typedi's Container.
+ */
+export function OrmTreeRepository(cls: Function, connectionName: string = "default"): Function {
+    return function(target: Object|Function, propertyName: string, index?: number) {
+
+        const getValue = () => {
+            const connectionManager = Container.get(ConnectionManager);
+            if (!connectionManager.has(connectionName))
+                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
+                    `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+                    `in your application before you established a connection and importing any entity.`);
+
+            const connection = connectionManager.get(connectionName);
+            return connection.getTreeRepository(cls as any);
+        };
+
+        if (index !== undefined) {
+            Container.registerParamHandler({ type: target as Function, index: index, getValue: getValue });
+        } else {
+            Container.registerPropertyHandler({ target: target as Function /* todo: looks like typedi wrong type here */, key: propertyName, getValue: getValue });
+        }
+    };
+}