Use TypeORM with DaloyJS

TypeORM gives you decorator-based entities and the active-record / data-mapper patterns familiar to Java and .NET teams. It runs best on the Node.js adapter.

One request through TypeORM

01clientHTTP requestGET /users/:id
02zodValidated inputparams.id is a uuid
03typeormRepository querygetRepository(User).findOneBy(...)
04responseTyped body200 UserSchema | 404

Zod validates the request, the handler gets a repository off the DataSource on state.db, runs the entity query, then the response schema checks the body on the way out.

1. Install

pnpm add typeorm reflect-metadata pg
pnpm add -D @types/node

TypeORM relies on reflect-metadata and decorator metadata. Make sure your tsconfig.json enables them:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "strictPropertyInitialization": false
  }
}

2. Define an entity

// src/db/entities/User.ts
import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from "typeorm";

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

  @Column({ unique: true })
  email!: string;

  @Column({ type: "text", nullable: true })
  name!: string | null;

  @CreateDateColumn({ name: "created_at" })
  createdAt!: Date;
}

3. Configure the DataSource

// src/db/data-source.ts
import "reflect-metadata";
import { DataSource } from "typeorm";
import { User } from "./entities/User.ts";

export const AppDataSource = new DataSource({
  type: "postgres",
  url: process.env.DATABASE_URL,
  entities: [User],
  migrations: ["src/db/migrations/*.ts"],
  synchronize: false, // use migrations in production
  logging: process.env.NODE_ENV !== "production",
});

4. Create a TypeORM plugin

// src/db/plugin.ts
import type { App } from "@daloyjs/core";
import { AppDataSource } from "./data-source.ts";

export const typeormPlugin = {
  name: "typeorm",
  async register(app: App) {
    if (!AppDataSource.isInitialized) {
      await AppDataSource.initialize();
    }
    app.decorate("db", AppDataSource);
    app.onClose(async () => {
      if (AppDataSource.isInitialized) await AppDataSource.destroy();
    });
  },
};

5. Augment app state types

Add the declare module block to the same module that creates the plugin, not to a separate .d.ts file. Declaration files are exempt from type-checking when skipLibCheck is on (the scaffolded default), so a broken import inside a .d.ts fails silently and state.db quietly degrades to any.

// src/db/plugin.ts (same module as the plugin above)
declare module "@daloyjs/core" {
  interface AppState {
    db: typeof AppDataSource;
  }
}

6. Use repositories in routes

// src/server.ts
import "reflect-metadata";
import { z } from "zod";
import { App } from "@daloyjs/core";
import { serve } from "@daloyjs/core/node";
import { typeormPlugin } from "./db/plugin.ts";
import { User } from "./db/entities/User.ts";

const app = new App();
app.register(typeormPlugin);

const UserSchema = z.object({
  id: z.uuid(),
  email: z.email(),
  name: z.string().nullable(),
  createdAt: z.coerce.date(),
});

app.get(
  "/users/:id",
  {
    operationId: "getUser",
    request: { params: z.object({ id: z.uuid() }) },
    responses: {
      200: { description: "Found", body: UserSchema },
      404: { description: "Not found" },
    },
  },
  async ({ params, state }) => {
    const repo = state.db.getRepository(User);
    const user = await repo.findOneBy({ id: params.id });
    return user
      ? { status: 200, body: user }
      : { status: 404, body: { type: "about:blank", title: "Not found", status: 404 } };
  },
);

app.post(
  "/users",
  {
    operationId: "createUser",
    request: { body: z.object({ email: z.email(), name: z.string().optional() }) },
    responses: { 201: { description: "Created", body: UserSchema } },
  },
  async ({ body, state }) => {
    const repo = state.db.getRepository(User);
    const created = await repo.save(repo.create(body));
    return { status: 201, body: created };
  },
);

await app.ready();
serve(app, { port: 3000 });

Transactions

handler: async ({ body, state }) => {
  return state.db.transaction(async (manager) => {
    const order = await manager.save(Order, manager.create(Order, body));
    await manager.decrement(Inventory, { sku: body.sku }, "stock", body.qty);
    return { status: 201, body: order };
  });
}

Migrations

pnpm typeorm migration:generate src/db/migrations/InitUser -d src/db/data-source.ts
pnpm typeorm migration:run -d src/db/data-source.ts

Runtime notes

TypeORM uses Node-only APIs (filesystem, native drivers). It does not run on Cloudflare Workers, use Drizzle or Supabase there.
On Bun and Deno, prefer drizzle-style postgres clients unless you need TypeORM's decorators.
Always import reflect-metadata once at the entrypoint, before anything else.

Compare with Prisma, Drizzle, MikroORM, Sequelize, or the ODM overview if you need document models.

Search docs