@cinnabun/db 0.0.7 → 0.0.9

package/README.md

@@ -1,6 +1,6 @@
 # @cinnabun/db
 
-Database module for the Cinnabun framework with adapter pattern supporting Drizzle ORM and Prisma.
+Database module for the Cinnabun framework with adapter pattern supporting Drizzle ORM and Prisma. Spring Data-style repositories with constructor injection.
 
 ## Installation
 
@@ -39,12 +39,13 @@ export const users = sqliteTable("users", {
 
 ```typescript
 // src/main.ts
+import "reflect-metadata";
 import { CinnabunApp, CinnabunFactory } from "@cinnabun/core";
 import { DatabaseModule, DatabasePlugin } from "@cinnabun/db";
 
 @CinnabunApp({
   port: 3000,
-  scanPaths: [],
+  scanPaths: ["./src"],
   imports: [
     DatabaseModule.forRoot({
       adapter: "drizzle",
@@ -52,27 +53,33 @@ import { DatabaseModule, DatabasePlugin } from "@cinnabun/db";
       autoMigrate: true,
     }),
   ],
-  plugins: [DatabaseModule.createPlugin()],
+  plugins: [new DatabasePlugin()],
 })
 class App {}
 
 CinnabunFactory.run(App);
 ```
 
-### 3. Use repositories in controllers
+### 3. Use repositories
 
 **Option A: Spring Data-style (constructor injection)**
 
+Extend `CrudRepositoryBase` and use `@RepositoryEntity`. The framework provides the implementation at runtime.
+
 ```typescript
-import { RestController, GetMapping, PostMapping, Body, Service } from "@cinnabun/core";
+// src/repositories/user.repository.ts
 import { RepositoryEntity, CrudRepositoryBase } from "@cinnabun/db";
-import { users } from "./schema";
+import { users } from "../schema";
 
 type User = typeof users.$inferSelect;
 
 @RepositoryEntity(users)
 abstract class UserRepository extends CrudRepositoryBase<User, number> {}
 
+// src/services/user.service.ts
+import { Service } from "@cinnabun/core";
+import { UserRepository } from "../repositories/user.repository.js";
+
 @Service()
 class UserService {
   constructor(private readonly userRepo: UserRepository) {}
@@ -81,11 +88,19 @@ class UserService {
     return this.userRepo.findAll();
   }
 
+  async findById(id: number) {
+    return this.userRepo.findById(id);
+  }
+
   async create(data: { name: string; email: string }) {
     return this.userRepo.save(data);
   }
 }
 
+// src/controllers/user.controller.ts
+import { RestController, GetMapping, PostMapping, Body } from "@cinnabun/core";
+import { UserService } from "../services/user.service.js";
+
 @RestController("/api/users")
 class UserController {
   constructor(private readonly userService: UserService) {}
@@ -102,7 +117,14 @@ class UserController {
 }
 ```
 
-Register `UserRepository` and `UserService` in your module's `providers` array.
+Register `UserRepository` and `UserService` in your module's `providers` array. With `scanPaths: ["./src"]`, scanned modules will discover them automatically.
+
+**Prisma:** Use the model name string instead of a table schema:
+
+```typescript
+@RepositoryEntity("Todo")
+abstract class TodoCrudRepository extends CrudRepositoryBase<Todo, string> {}
+```
 
 **Option B: InjectRepository (property injection)**
 
@@ -134,11 +156,17 @@ class UserController {
 
 ## Transactions
 
-Use `@Transactional()` to wrap methods in database transactions:
+Use `@Transactional()` to wrap methods in database transactions. Inject `TransactionManager` and pass it to the decorator when using constructor-injected repositories:
 
 ```typescript
 import { Service } from "@cinnabun/core";
-import { Transactional, InjectRepository, Repository, RepositoryFactory, TransactionManager } from "@cinnabun/db";
+import {
+  Transactional,
+  InjectRepository,
+  Repository,
+  RepositoryFactory,
+  TransactionManager,
+} from "@cinnabun/db";
 import { users, profiles } from "./schema";
 
 @Service()
@@ -192,23 +220,15 @@ interface DatabaseModuleOptions {
 
 ## Repository API
 
-**CrudRepository** (Spring Data-style, use with `@RepositoryEntity`):
+**CrudRepositoryBase** (Spring Data-style) — extend this with `@RepositoryEntity`. Do not implement `CrudRepository` directly; TypeScript requires all methods to be implemented.
 
 ```typescript
-interface CrudRepository<T, ID> {
-  findById(id: ID): Promise<T | null>;
-  findAll(options?: QueryOptions): Promise<T[]>;
-  findOne(where: Partial<T>): Promise<T | null>;
-  findMany(where: Partial<T>, options?: QueryOptions): Promise<T[]>;
-  save(entity: Partial<T>): Promise<T>;
-  saveAll(entities: Partial<T>[]): Promise<T[]>;
-  deleteById(id: ID): Promise<void>;
-  delete(entity: T): Promise<void>;
-  existsById(id: ID): Promise<boolean>;
-  count(where?: Partial<T>): Promise<number>;
-}
+@RepositoryEntity(users)
+abstract class UserRepository extends CrudRepositoryBase<User, number> {}
 ```
 
+Methods: `findById`, `findAll`, `findOne`, `findMany`, `save`, `saveAll`, `deleteById`, `delete`, `existsById`, `count`.
+
 **Repository** (lower-level, use with `@InjectRepository`):
 
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cinnabun/db",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Database module for Cinnabun with Drizzle and Prisma adapters",
   "type": "module",
   "main": "dist/index.js",