BananaJSAI-first, DDD-ready Node.js framework for high-velocity teams

// Issue.dto.ts — generated schemas (edit freely)
import { z } from 'zod'

export const CreateIssueSchema = z.object({
  title:      z.string().min(1).max(200),
  projectId:  z.string().min(1),
  priority:   z.enum(['low', 'medium', 'high', 'critical']),
  assigneeId: z.string().optional(),
})

export const UpdateIssueSchema = CreateIssueSchema
  .partial()
  .extend({ status: z.enum(['open', 'in-progress', 'done']).optional() })

// Types are fully inferred — no separate interface needed
export type CreateIssueDto = z.infer<typeof CreateIssueSchema>
export type UpdateIssueDto = z.infer<typeof UpdateIssueSchema>

// Issue.controller.ts — HTTP layer only
@injectable()
@Controller('issues')
export class IssueController extends BaseController {
  constructor(
    @inject(IssueAppService)
    private readonly app: IssueAppService,
  ) { super() }

  @Post('')
  @Body(CreateIssueSchema)            // 400 on schema failure — automatic
  async create(req: Request, res: Response) {
    return this.ok(res, 'created', await this.app.create(req.body))
  }

  @Put(':id')
  @Params(z.object({ id: z.string().min(1) }))
  @Body(UpdateIssueSchema)
  async update(req: Request, res: Response) {
    return this.ok(res, 'ok', await this.app.update(req.params.id, req.body))
  }

  @Get('')
  @Query(z.object({ projectId: z.string().min(1) }))
  async list(req: Request, res: Response) {
    return this.ok(res, 'ok', await this.app.findByProject(req.query.projectId as string))
  }
}

// application/Issue.service.ts
@injectable()
export class IssueAppService {
  constructor(
    @inject(IssueRepositoryToken)
    private readonly repo: IssueRepository,   // port, not Mongoose
  ) {}

  async create(dto: CreateIssueDto): Promise<Issue> {
    const issue = this.repo.create({ ...dto, status: 'open' })
    return this.repo.save(issue)
  }

  async update(id: string, dto: UpdateIssueDto): Promise<Issue> {
    const issue = await this.repo.findById(id)
    if (!issue) throw new NotFoundError('Issue', id)
    issue.update(dto)             // domain rule lives in the entity
    return this.repo.save(issue)
  }

  async findByProject(projectId: string): Promise<Issue[]> {
    return this.repo.findByProject(projectId)
  }
}

// domain/Issue.repository.ts — ORM-agnostic interface (port)
export interface IssueRepository {
  save(issue: Issue): Promise<Issue>
  findById(id: string): Promise<Issue | null>
  findByProject(projectId: string): Promise<Issue[]>
}

// Symbol token — used by tsyringe for DI
export const IssueRepositoryToken = Symbol('IssueRepository')

// Wired once in index.ts → createModule({
//   providers: [
//     { token: IssueRepositoryToken,
//       useClass: IssueMongooseRepository },  ← swap freely
//   ]
// })
// The service never changes when you swap adapters.

// infrastructure/Issue.mongoose-repository.ts
@injectable()
export class IssueMongooseRepository implements IssueRepository {
  async save(issue: Issue): Promise<Issue> {
    await IssueModel.findOneAndUpdate(
      { _id: issue.id },
      toDocument(issue),
      { upsert: true },
    )
    return issue
  }

  async findById(id: string): Promise<Issue | null> {
    const doc = await IssueModel.findById(id).lean()
    return doc ? toDomain(doc) : null
  }

  async findByProject(projectId: string): Promise<Issue[]> {
    const docs = await IssueModel
      .find({ projectId })
      .sort({ createdAt: -1 })
      .lean()
    return docs.map(toDomain)
  }
}

// src/modules/issue/index.ts — generated DI wiring
import { createModule } from '@banana-universe/bananajs'
import { IssueController } from './Issue.controller.js'
import { IssueAppService } from './application/Issue.service.js'
import { IssueRepositoryToken } from './domain/Issue.repository.js'
import { IssueMongooseRepository } from './infrastructure/Issue.mongoose-repository.js'

export const issueModule = createModule({
  id: 'issue',
  controller: IssueController,
  providers: [
    IssueAppService,
    {
      token: IssueRepositoryToken,
      useClass: IssueMongooseRepository,   // ← swap for any adapter
    },
  ],
})

// Register in bootstrap.ts:
import { BananaApp } from '@banana-universe/bananajs'
import { mongoosePlugin } from '@banana-universe/plugin-mongoose'

const app = await BananaApp.create({
  plugins: [mongoosePlugin({ uri: process.env.MONGO_URI! })],
  modules: [issueModule],   // ← add more modules here
})
app.listen(3000)

// bjs ai test → writes src/__tests__/issue.test.ts
import { BananaTestApp } from '@banana-universe/bananajs/testing'
import { issueModule } from '../modules/issue/index.js'
import assert from 'node:assert/strict'
import { describe, it, before, after } from 'node:test'
import request from 'supertest'

describe('IssueController', () => {
  let app: BananaTestApp

  before(async () => {
    app = await BananaTestApp.create({ modules: [issueModule] })
  })
  after(() => app.close())

  it('POST /issues returns 201', async () => {
    const res = await request(app.server)
      .post('/issues')
      .send({ title: 'Fix login bug', projectId: 'p1', priority: 'high' })
    assert.equal(res.status, 201)
  })

  it('POST /issues returns 400 on bad payload', async () => {
    const res = await request(app.server)
      .post('/issues').send({ title: '' })
    assert.equal(res.status, 400)
  })
})