@alevnyacow/nzmt 0.13.1 → 0.14.0

package/README.md

@@ -36,7 +36,6 @@ npm install inversify zod reflect-metadata @alevnyacow/nzmt
 
 2. Enable `Experimental decorators` and `Emit Decorator Metadata` options in your `tsconfig.json`.
 ```json
-// tsconfig.json
 {
   "compilerOptions": {
     "experimentalDecorators": true,
@@ -45,7 +44,7 @@ npm install inversify zod reflect-metadata @alevnyacow/nzmt
 }
 ```
 
-3. Initialize NZMT. This will set up all required infrastructure and configuration for you:
+3. Initialize NZMT (must be done once). This will set up all required infrastructure and configuration for you:
 ```bash
 npx nzmt init prismaClientPath:@/app/generated/prisma/client
 ```
@@ -58,29 +57,17 @@ npx nzmt crud-api user
 This will generate:
 
 - `User` entity
-- `UserStore` contract, `UserRAMStore` and `UserPrismaStore` implementation
+- `UserStore` contract, `UserRAMStore` and `UserPrismaStore` implementations
 - `UserService` proxying all `UserStore` methods
-- `UserController` proxying all `UserService` methods. 
+- `UserController` proxying all `UserService` methods 
+- API `route handlers` can be used from client 
 
 All code is editable - you stay in full control.
 
 5. **Describe entity properties and validation rules using Zod** for the `User` entity in the scaffolded file `/shared/entities/user/user.entity.ts`.
 
 6. **Implement Prisma mappers** in `/server/stores/user/user.store.prisma.ts`.  
-All methods and contracts are already scaffolded; you only need to describe the mappers themselves.
-
-7. Use generated controller in `app/api/user/route.ts` file via DI.
-
-```ts
-import type { UserController } from "@/server/controllers/user"
-import { fromDI } from "@/server/di"
-
-// Get a fully typed controller instance from the DI container.
-// Key is fully typed too, of course.
-const controller = fromDI<UserController>('UserController')
-// Use controller method as a route method.
-export const GET = controller.GET
-```
+All methods and contracts are already scaffolded; you only need to describe the mappers themselves. RAM store implementation works out of the box.
 
 # Design principles
 
@@ -107,63 +94,6 @@ There are also two building blocks shared across server and client: Entities and
 - **Entities** represent domain objects used throughout the application. They don’t include data access or business flow logic, but may contain pure domain logic, contracts and invariants (e.g. User, Product).
 - **Value Objects** define reusable, strongly-typed invariants for meaningful concepts such as Pagination or Identifier.
 
-# Scaffolding
-
-## Setup
-
-```
-npx nzmt init prismaClientPath:@/app/generated/prisma/client
-```
-This creates `nzmt.config.json`, sets up DI and testing, and adds base providers. `prismaClientPath:...` parameter is optional and enables Prisma scaffolding.
-
-## Naming conventions
-
-- The entity name is expected to be **in `kebab-case`** (e.g. `awesome-user`, `product`).
-- The entity name is expected to be **in singular form** (e.g. `product` instead of `products`).
-
-## Shared layer modules
-
-### Entities
-
-Example: scaffolding a `User` entity with two fields (name and age).
-
-```bash
-npx nzmt entity user f:name-string,age-int.positive
-```
-
-You can define entity fields using the `f:` flag. The format is `name-type`, where `type` maps to Zod (e.g. `int.positive` → `z.int().positive()`). This is optional — `npx nzmt entity user` will scaffold a `User` entity without additional fields.
-
-Entity scaffolder generates a dedicated folder with a barrel file and an entity implementation. Generated code is fully editable — you stay in control. 
-
-The generated `user.entity.ts` looks like this:
-
-```ts
-import z from 'zod'
-import { ValueObjects } from '@alevnyacow/nzmt'
-
-export type UserModel = z.infer<typeof User.schema>
-
-export class User {
-    static schema = z.object({
-        id: ValueObjects.Identifier.schema,
-        name: z.string(),
-        age: z.int().positive(),
-    })
-    
-    private constructor(private readonly data: UserModel) {}
-    
-    static create = (data: UserModel) => {
-        const parsedModel = User.schema.parse(data)
-        return new User(parsedModel)
-    }
-    
-    get model(): UserModel {
-        return this.data
-    }
-}
-```
-
-`User` entity, `User.schema` zod schema and `UserModel` type can be used wherever they are needed.
 
 # Package API
 

package/bin/cli.js

@@ -980,6 +980,63 @@ function generateController(upperCase, lowerCase, crudService) {
     )
 }
 
+function generateAPIRoutes(lowerCase, upperCase) {
+    const projectRoot = findProjectRoot()
+    const fileText = fs.readFileSync(
+        path.resolve(projectRoot, `${config.coreFolder}${config.paths.controllers}`, entityName, `${entityName}.controller.ts`),
+        'utf-8'
+    )
+
+    const regex = /^\s*(\w+)\s*=\s*this\.endpoints/mg
+    const methods = Array.from(fileText.matchAll(regex), m => m[1])
+
+    const methodInfo = methods.map(method => ({method: method.split('_').pop(), path: method.split('_').slice(0, -1).join('/')}))
+
+    const rootMethods = methodInfo.filter(x => !x.path.length).map(x => x.method)
+    const nestedMethods = methodInfo.filter(x => !!x.path.length).reduce((acc, cur) => {
+        if (!acc[cur.path]) {
+            acc[cur.path] = []
+        }
+        acc[cur.path].push(cur.method)
+        return acc
+    }, {})
+
+    const controllerHandlersRootPath = path.resolve(projectRoot, config.coreFolder, 'app', 'api', `${entityName}-controller`)
+    
+    fs.mkdirSync(controllerHandlersRootPath, { recursive: true })
+
+    if (rootMethods.length) {
+        fs.writeFileSync(path.resolve(controllerHandlersRootPath, 'route.ts'), [
+            `import type { ${upperCase}Controller } from '@${config.paths.controllers}/${entityName}'`,
+            `import { fromDI } from '@${config.paths.di}'`,
+            '',
+            `const controller = fromDI<${upperCase}Controller>('${upperCase}Controller')`,
+            '',
+            rootMethods.map(x => `export const ${x} = controller.${x}`).join('\n')
+        ].join('\n'))
+    }
+
+    for (const [currentPath, methods] of Object.entries(nestedMethods)) {
+        const nestedFolder = path.resolve(controllerHandlersRootPath, currentPath)
+        fs.mkdirSync(nestedFolder, { recursive: true })
+        fs.writeFileSync(path.resolve(nestedFolder, 'route.ts'), [
+            `import type { ${upperCase}Controller } from '@${config.paths.controllers}/${entityName}'`,
+            `import { fromDI } from '@${config.paths.di}'`,
+            '',
+            `const controller = fromDI<${upperCase}Controller>('${upperCase}Controller')`,
+            '',
+            methods.map(x => `export const ${x} = controller.${currentPath.replaceAll('/', '_')}_${x}`).join('\n')
+        ].join('\n'))
+    }   
+}
+
+
+if (command === 'api-routes') {
+    var [lowerCase, upperCase] = camelizeVariants(entityName)
+
+    generateAPIRoutes(lowerCase, upperCase)
+}
+
 if (command.toLowerCase() === 'controller' || command === 'c') {
     var [lowerCase, upperCase] = camelizeVariants(entityName)
     generateController(upperCase, lowerCase)
@@ -1007,5 +1064,6 @@ if (command.toLowerCase() === 'crud-api') {
     generateStores(lowerCase, upperCase, true)
     generateService(lowerCase, upperCase, upperCase + 'Store')
     generateController(upperCase, lowerCase, upperCase + 'Service')
+    generateAPIRoutes(lowerCase, upperCase)
     process.exit(0)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alevnyacow/nzmt",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Next Zod Modules Toolkit",
   "repository": {
     "type": "git",