Controller + Service + Repository pattern with DrizzleORM

action.service.ts

export class ActionService {
  constructor(private actionReposiory: ActionReposiory) {
    this.actionReposiory = actionReposiory;
  }

  async createAction(dto: any) {
    return await this.actionReposiory.createAction(dto);
  }
}

actions.repository.ts

export class ActionReposiory {
  async createAction(dto: any) {
    return await db.insert(Action).values(dto).returning().execute();
  }
}

actions.schema.ts

export const Action = pgTable("actions", {
  id: integer("id").primaryKey().notNull(),
  userId: integer("user_id").notNull(),
});

db.ts

export const client = postgres(envs.POSTGRES_URL);
export const db = drizzle(client);

index.ts

const userReposiory = new UserReposiory();
const actionReposiory = new ActionReposiory();

const userService = new UserService(userReposiory);
const actionService = new ActionService(actionReposiory);

const userController = new UserController(userService, actionService);

user.controller.ts

export class UserController {
  constructor(private userService: UserService, private actionService: ActionService) {
    this.userService = userService;
    this.actionService = actionService;
  }
  async createUser(dto: any) {
    await db.transaction(async () => {
      const user = await this.userService.createUser(dto);
      const action = await this.actionService.createAction({ userId: user.id, type: "createUser" });
      return { user, action };
    });
  }
}

users.reposiory.ts

export class UserReposiory {
  async createUser(dto: any) {
    return await db.insert(User).values(dto).returning().execute();
  }
}

users.schema.ts

export const User = pgTable("users", {
  id: integer("id").primaryKey().notNull(),
});

users.service.ts

export class UserService {
  constructor(private userReposiory: UserReposiory) {
    this.userReposiory = userReposiory;
  }

  async createUser(dto: any) {
    return await this.userReposiory.createUser(dto);
  }
}