initial version

Author: AngusLin10

.gitignore

@@ -0,0 +1,6 @@
+.idea/
+.vscode/
+node_modules/
+build/
+tmp/
+temp/

database.sqlite

@@ -0,0 +1,25 @@
+{
+   "name": "typeorm_express",
+   "version": "0.0.1",
+   "description": "Awesome project developed with TypeORM.",
+   "type": "commonjs",
+   "devDependencies": {
+      "ts-node": "10.9.1",
+      "@types/node": "^16.11.10",
+      "typescript": "4.5.2"
+   },
+   "dependencies": {
+      "typeorm": "0.3.20",
+      "reflect-metadata": "^0.1.13",
+      "sqlite3": "^5.0.2",
+      "express": "^4.17.2",
+      "body-parser": "^1.19.1"
+   },
+   "scripts": {
+      "start": "ts-node src/index.ts",
+      "typeorm": "typeorm-ts-node-commonjs",
+      "migration:run": "typeorm-ts-node-commonjs migration:run -d ./src/data-source.ts",
+      "migration:revert": "typeorm-ts-node-commonjs migration:revert -d ./src/data-source.ts",
+      "migration:show": "typeorm-ts-node-commonjs migration:show -d ./src/data-source.ts"
+   }
+}

package-lock.json

@@ -0,0 +1,53 @@
+import { AppDataSource } from "../data-source"
+import { NextFunction, Request, Response } from "express"
+import { User } from "../entity/User"
+
+export class UserController {
+
+    private userRepository = AppDataSource.getRepository(User)
+
+    async all(request: Request, response: Response, next: NextFunction) {
+        return this.userRepository.find()
+    }
+
+    async one(request: Request, response: Response, next: NextFunction) {
+        const id = parseInt(request.params.id)
+
+
+        const user = await this.userRepository.findOne({
+            where: { id }
+        })
+
+        if (!user) {
+            return "unregistered user"
+        }
+        return user
+    }
+
+    async save(request: Request, response: Response, next: NextFunction) {
+        const { firstName, lastName, age } = request.body;
+
+        const user = Object.assign(new User(), {
+            firstName,
+            lastName,
+            age
+        })
+
+        return this.userRepository.save(user)
+    }
+
+    async remove(request: Request, response: Response, next: NextFunction) {
+        const id = parseInt(request.params.id)
+
+        let userToRemove = await this.userRepository.findOneBy({ id })
+
+        if (!userToRemove) {
+            return "this user not exist"
+        }
+
+        await this.userRepository.remove(userToRemove)
+
+        return "user has been removed"
+    }
+
+}

package.json

@@ -0,0 +1,15 @@
+import "reflect-metadata"
+import { DataSource } from "typeorm"
+// import { User } from "./entity/User"
+
+export const AppDataSource = new DataSource({
+    type: "sqlite",
+    database: "database.sqlite",
+    synchronize: false,
+    migrationsRun: true,
+    logging: false,
+    // entities: [User],
+    entities: ["src/entity/*.ts"],
+    migrations: ["src/migration/*.ts"],
+    subscribers: [],
+})

src/controller/UserController.ts

@@ -0,0 +1,20 @@
+import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"
+
+@Entity()
+export class User {
+
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    firstName: string
+
+    @Column()
+    lastName: string
+
+    @Column()
+    age: number
+
+    @Column()
+    email: string
+}

src/data-source.ts

@@ -0,0 +1,52 @@
+import * as express from "express"
+import * as bodyParser from "body-parser"
+import { Request, Response } from "express"
+import { AppDataSource } from "./data-source"
+import { Routes } from "./routes"
+import { User } from "./entity/User"
+
+AppDataSource.initialize().then(async () => {
+
+    // create express app
+    const app = express()
+    app.use(bodyParser.json())
+
+    // register express routes from defined application routes
+    Routes.forEach(route => {
+        (app as any)[route.method](route.route, (req: Request, res: Response, next: Function) => {
+            const result = (new (route.controller as any))[route.action](req, res, next)
+            if (result instanceof Promise) {
+                result.then(result => result !== null && result !== undefined ? res.send(result) : undefined)
+
+            } else if (result !== null && result !== undefined) {
+                res.json(result)
+            }
+        })
+    })
+
+    // setup express app here
+    // ...
+
+    // start express server
+    app.listen(3000)
+
+    // insert new users for test
+    // await AppDataSource.manager.save(
+    //     AppDataSource.manager.create(User, {
+    //         firstName: "Timber",
+    //         lastName: "Saw",
+    //         age: 27
+    //     })
+    // )
+
+    // await AppDataSource.manager.save(
+    //     AppDataSource.manager.create(User, {
+    //         firstName: "Phantom",
+    //         lastName: "Assassin",
+    //         age: 24
+    //     })
+    // )
+
+    console.log("Express server has started on port 3000. Open http://localhost:3000/users to see results")
+
+}).catch(error => console.log(error))

src/entity/User.ts

@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class User1709803221770 implements MigrationInterface {
+    name = 'User1709803221770'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "user" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "firstName" varchar NOT NULL, "lastName" varchar NOT NULL, "age" integer NOT NULL)`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP TABLE "user"`);
+    }
+
+}

src/index.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
+
+export class User1709864174745 implements MigrationInterface {
+    name = 'User1709864174745'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        // await queryRunner.query(`ALTER TABLE "user" ADD COLUMN "email" varchar varchar`);
+        await queryRunner.addColumn('user', {
+            name: 'email',
+            type: 'varchar',
+            isNullable: true,
+            '@instanceof': undefined,
+            isGenerated: false,
+            isPrimary: false,
+            isUnique: false,
+            isArray: false,
+            length: '',
+            zerofill: false,
+            unsigned: false,
+            clone: function (): TableColumn {
+                throw new Error('Function not implemented.')
+            }
+        })
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        // await queryRunner.query(`ALTER TABLE "user" DROP COLUMN "email"`);
+        await queryRunner.dropColumn('user', 'email')
+    }
+}