View source for Node Express Typescript 2024

[[Category:Node.js]]
[[Category:Typescript]]
[[Category:Express]]
== Setup. ==
terminal : 
<pre>
npm init -y
npm i --save express dotenv
npm i -D typescript @types/node  @types/express nodemon ts-node
npx tsc --init
</pre>
 

tsconfig.json
<pre>
"rootDir": "./src", 
"outDir": "./dist",
</pre>

package.json -> 
<pre>
{
  "name": "logicmade_api",
  "version": "1.0.0",
  "description": "API for many things needed",
  "main": "index.js",
  "scripts": {
    "build": "npx tsc",
    "start": "node dist/index.js",
    "dev": "nodemon src/index.ts",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@types/express": "^4.17.21",
    "@types/node": "^20.11.28",
    "nodemon": "^3.1.0",
    "ts-node": "^10.9.2",
    "typescript": "^5.4.2"
  },
  "dependencies": {
    "dotenv": "^16.4.5",
    "express": "^4.18.3"
  }
}
</pre>
.env file
<pre>
PORT=3000
</pre>
./src/index.ts -> 
<pre>
import express, {Express, Request, Response } from "express"
import dotenv from "dotenv"

dotenv.config()

const app: Express  = express()
const port = 3000

console.log("env : ", process.env.PORT )
app.get("/", (req:Request, res:Response) => {
    res.send("OK")
})

app.listen(port, ()=> {
    console.log(`[server]: Server is running at http://localhost:${port}`)
})
</pre>

== Vitest ==
<pre>
npm i -D vitest 
npm i -D @vitest/ui
</pre>

package.json -> 
<pre>
"scripts": {
...
    "test": "vitest",
    "test:ui": "vitest --ui",
    "coverage": "vitest run --coverage"
  },
</pre>

== Morgan (Logging the requests) ==
<pre>
npm i -S morgan
npm i -D @types/morgan
npm i rotating-file-stream
</pre>

/src/index.ts
<pre>
import morgan from "morgan"
import  { createStream } from "rotating-file-stream"
import path from "path"
...
import Router from "./routes"
...
var accessLogStream = createStream('access.log', {
    interval: '1d', // rotate daily
    path: path.join(__dirname, '../log')
})
...
app.use(express.json());
app.use(morgan('combined', { stream: accessLogStream }));
app.use(express.static("public"));

app.use(Router);

</pre>
/src/routes/index.ts
<pre>
import express from "express";
import PingController from "../controllers/ping";

const router = express.Router();

router.get("/ping", async (_req, res) => {
  const controller = new PingController();
  const response = await controller.getMessage();
  return res.send(response);
});

export default router;
</pre>
/src/controller/ping.ts
<pre>
interface PingResponse {
    message: string;
  }
  
  export default class PingController {
    public async getMessage(): Promise<PingResponse> {
      return {
        message: "hello",
      };
    }
  }
</pre>

== Swagger ==
<pre>
npm i -S tsoa swagger-ui-express
npm i -D @types/swagger-ui-express concurrently
</pre>

tsconfig.json
<pre>
{
  "compilerOptions": {
    ...
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}
</pre>
tsoa.json (create)
<pre>
{
  "entryFile": "src/index.ts",
  "noImplicitAdditionalProperties": "throw-on-extras",
  "spec": {
    "outputDirectory": "public",
    "specVersion": 3
  }
}
</pre>
If bearer token will be used then json should be like below.    
<pre>
{
    "entryFile": "src/index.ts",
    "noImplicitAdditionalProperties": "throw-on-extras",
    "spec": {
      "outputDirectory": "public",
      "specVersion": 3,
      "securityDefinitions": {
        "BearerAuth": {
          "type": "http",
          "scheme": "bearer"
        }
      }
    },
    "ignore": ["**/node_modules/**"]
    
  }
</pre>
For other security options see [https://tsoa-community.github.io/docs tsoa documentation]. Some other samples are below 
<pre>
    "securityDefinitions": {
      "api_key": {
        "type": "apiKey",
        "name": "access_token",
        "in": "query"
      },
      "tsoa_auth": {
        "type": "oauth2",
        "authorizationUrl": "http://swagger.io/api/oauth/dialog",
        "flow": "implicit",
        "scopes": {
          "write:pets": "modify things",
          "read:pets": "read things"
        }
      }
    },
</pre>

package.json 
<pre>
  "nodemonConfig": {
    "watch": [
      "src"
    ],
    "ext": "ts",
    "exec": "ts-node src/index.ts"
  },
"scripts": {
    "predev": "npm run swagger",
    "prebuild": "npm run swagger",
    "build": "npx tsc",
    "start": "node dist/index.js",
    "dev": "concurrently \"nodemon\" \"nodemon -x tsoa spec\"",
    "swagger": "tsoa spec",
    ...
  },

</pre>
'''Usage of Concurrently :''' concurrently 'command1 arg' 'command2 arg'


src/index.ts
<pre>
import express, { Application, Request, Response } from "express";
import morgan from "morgan";
import swaggerUi from "swagger-ui-express";

import Router from "./routes";

const PORT = process.env.PORT || 8000;

const app: Application = express();

app.use(express.json());
app.use(morgan("tiny"));
app.use(express.static("public"));

app.use(
  "/docs",
  swaggerUi.serve,
  swaggerUi.setup(undefined, {
    swaggerOptions: {
      url: "/swagger.json",
    },
  })
);

app.use(Router);
</pre>
src/controllers/ping.ts
<pre>
import { Get, Route } from "tsoa";

interface PingResponse {
  message: string;
}

@Route("ping")
export default class PingController {
  @Get("/")
  public async getMessage(): Promise<PingResponse> {
    return {
      message: "hello",
    };
  }
}
</pre>
After making all the changes and running the server, visit http://localhost:3000/docs/ to access the APIs documentation.

== Drizzle (left uncompleted) ==
Depending on the database select packages to install by checking [https://orm.drizzle.team/docs/overview Drizzle docs]

=== Neon ===
Neon provides postgres db in the cloud. Check : [https://neon.tech/ neon official web site]
=== Drizzle setup ===
<pre>
npm i drizzle-orm @neondatabase/serverless
npm i -D drizzle-kit
</pre>

/db/db.ts (different from original doc because of type error)
<pre>
import { neon } from '@neondatabase/serverless';
import type { NeonQueryFunction } from "@neondatabase/serverless";
import { drizzle } from 'drizzle-orm/neon-http';

const sql: NeonQueryFunction<boolean, boolean> = neon(process.env.DRIZZLE_DATABASE_URL!);
const db = drizzle(sql);
export default db;
</pre>

'''I couldn't find automatic schema updates in drizzle and swithing back to TypeORM''' 
== TypeORM ==
 npm i typeorm pg
/src/config/config.ts
<pre>
const config = {
    db:{
        sync:true,
        migration:true
    }
}
export default config
</pre>
/src/db/connection.ts
<pre>
import { DataSourceOptions } from "typeorm";
import dotenv from "dotenv"

dotenv.config()
const config : DataSourceOptions = {
    type: "postgres",
    host:  process.env.DB_HOST,
    username: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME ,
    entities:[
        "src/db/entities/**/*.ts"
    ],
    migrations: [
        "src/db/migrations/**/*.ts"
    ],
    synchronize: true,
    logging: false,
    migrationsRun: false,
    extra: {
        ssl: true
      }
}
export default config
</pre>
''extra is needed for neon postgres sql''

/src/db/dbSource.ts
<pre>
import {DataSource} from "typeorm";
import connection from './connection'
import config from "../config/config"

const DbSource = new DataSource(connection)

DbSource.initialize()
    .then(() => {
        console.log("Database connected - " + connection.database)
        if(config.db.sync?.toString()=="true"){
          DbSource.synchronize().then(() => {
            console.log("Database syncronized")
            if(config.db.migration?.toString()=="true"){
              DbSource.runMigrations().then(()=>{
                console.log("Database migrations run")
              })
            }
          })
        }
}).catch(err => {
  console.log("Unable to connect to db", err);
  process.exit(1)
})
 

export default DbSource
</pre>

/src/db/entities/user.entity.ts
<pre>
import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity("logicUser")
export class User {
    @PrimaryGeneratedColumn("uuid")
    id!: string;

    @Column()
    fullname!: string;
 
    @Column({nullable:true})
    description!: string;

    @Column({nullable:true})
    email!: string;
}
</pre>
''There is a similar model class'' 


/src/repositories/user.repository.ts
<pre>
import crypto from 'crypto'
import DbSource from '../db/dbSource';
import { User } from '../db/entities/user.entity';
import { RetVal } from '../models/retval.model';
import { UserModel } from '../models/user.model';
 
export const getUser = async (id:string) : Promise<RetVal> => { 
    const userRepository = DbSource.getRepository(User);
    try{ 
    const result = await userRepository.findOne({
        where:{
            id:id
        },
    })
 
    return  new RetVal(null, result)
    }catch{
        return new RetVal(Error("No record found for given id"), null) 
    }
}

export const getUsers = async () : Promise<RetVal> => { 
    const userRepository = DbSource.getRepository(User);
    try{ 
    const result = await userRepository.find({
        order:{fullname:"ASC"}

    })
 
    return  new RetVal(null, result)
    }catch{
        return new RetVal(Error("No record found for given id"), null) 
    }
}

export const addUser = async (model : UserModel) : Promise<RetVal>  => {
    const userRepository = DbSource.getRepository(User);
    const userEntity = userRepository.create({
        id:crypto.randomUUID(),
        fullname:model.fullname,
        description:model.description,
        email:model.email
    })
    try{
        const result = await userRepository.save(userEntity);
        return new RetVal(null, result)
    }catch(error){
        let message;
        if (error instanceof Error) message = "Error : " + error.message
      
        return new RetVal(Error("Error saving company"), null)
    }
}
 

</pre>