@apso/cli 0.7.4 → 0.8.2

package/dist/lib/templates/python/routers/router.eta

@@ -0,0 +1,206 @@
+<%~ includeFile('../header.eta', it) %>
+
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from ..models.<%= it.entityName.toLowerCase() %> import <%= it.entityName -%>
+
+from ..schemas.<%= it.entityName.toLowerCase() %> import (
+    <%= it.entityName %> as <%= it.entityName %>Schema,
+    <%= it.entityName %>Create,
+    <%= it.entityName %>Update,
+    <%= it.entityName %>List,
+)
+from ..services.<%= it.entityName.toLowerCase() %> import <%= it.entityName %>Service
+
+router = APIRouter(
+    prefix="/<%= it.pluralEntityName.toLowerCase() %>",
+    tags=["<%= it.pluralEntityName %>"],
+)
+
+
+@router.get(
+    "",
+    response_model=<%= it.entityName %>List,
+    summary="Retrieve multiple <%= it.pluralEntityName %>",
+)
+async def get_many(
+    db: AsyncSession = Depends(get_db),
+    skip: int = Query(0, ge=0),
+    limit: int = Query(10, ge=1, le=100),
+    sort: Optional[str] = Query(None, description="Sort field (prefix with - for descending)"),
+<% /* Add filter parameters for common fields */ %>
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { %>
+    <%= assoc.camelCasedId %>: Optional[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>str<% } else { %>int<% } %>] = Query(None),
+<% }) %>
+) -> <%= it.entityName %>List:
+    """
+    Retrieve a paginated list of <%= it.pluralEntityName %>.
+    """
+    service = <%= it.entityName %>Service(db)
+
+    filters = {}
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { %>
+    if <%= assoc.camelCasedId %> is not None:
+        filters["<%= assoc.camelCasedId %>"] = <%= assoc.camelCasedId %>
+<% }) %>
+
+    items, total = await service.get_many(
+        skip=skip,
+        limit=limit,
+        sort=sort,
+        filters=filters,
+    )
+
+    return <%= it.entityName %>List(
+        data=items,
+        total=total,
+        page=(skip // limit) + 1 if limit > 0 else 1,
+        pageSize=limit,
+        totalPages=(total + limit - 1) // limit if limit > 0 else 1,
+    )
+
+
+@router.get(
+    "/{id}",
+    response_model=<%= it.entityName %>Schema,
+    summary="Retrieve a single <%= it.entityName %>",
+)
+async def get_one(
+    id: <% if (it.primaryKeyType === 'uuid') { %>str<% } else { %>int<% } %>,
+    db: AsyncSession = Depends(get_db),
+<% /* Add join parameters */ %>
+<% it.associations.forEach((assoc) => { %>
+<% if (assoc.type === 'OneToMany' || assoc.type === 'ManyToMany') { %>
+    join_<%= assoc.pluralizedRelationshipName %>: bool = Query(False, alias="join[<%= assoc.pluralizedRelationshipName %>]"),
+<% } else { %>
+    join_<%= assoc.relationshipName %>: bool = Query(False, alias="join[<%= assoc.relationshipName %>]"),
+<% } %>
+<% }) %>
+) -> <%= it.entityName %>Schema:
+    """
+    Retrieve a single <%= it.entityName %> by ID.
+    """
+    service = <%= it.entityName %>Service(db)
+
+    joins = []
+<% it.associations.forEach((assoc) => { %>
+<% if (assoc.type === 'OneToMany' || assoc.type === 'ManyToMany') { %>
+    if join_<%= assoc.pluralizedRelationshipName %>:
+        joins.append("<%= assoc.pluralizedRelationshipName %>")
+<% } else { %>
+    if join_<%= assoc.relationshipName %>:
+        joins.append("<%= assoc.relationshipName %>")
+<% } %>
+<% }) %>
+
+    item = await service.get_one(id, joins=joins)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"<%= it.entityName %> with id {id} not found",
+        )
+    return item
+
+
+@router.post(
+    "",
+    response_model=<%= it.entityName %>Schema,
+    status_code=status.HTTP_201_CREATED,
+    summary="Create a single <%= it.entityName %>",
+)
+async def create_one(
+    data: <%= it.entityName %>Create,
+    db: AsyncSession = Depends(get_db),
+) -> <%= it.entityName %>Schema:
+    """
+    Create a new <%= it.entityName %>.
+    """
+    service = <%= it.entityName %>Service(db)
+    return await service.create_one(data)
+
+
+@router.post(
+    "/bulk",
+    response_model=List[<%= it.entityName %>Schema],
+    status_code=status.HTTP_201_CREATED,
+    summary="Create multiple <%= it.pluralEntityName %>",
+)
+async def create_many(
+    data: List[<%= it.entityName %>Create],
+    db: AsyncSession = Depends(get_db),
+) -> List[<%= it.entityName %>Schema]:
+    """
+    Create multiple <%= it.pluralEntityName %>.
+    """
+    service = <%= it.entityName %>Service(db)
+    return await service.create_many(data)
+
+
+@router.patch(
+    "/{id}",
+    response_model=<%= it.entityName %>Schema,
+    summary="Update a single <%= it.entityName %>",
+)
+async def update_one(
+    id: <% if (it.primaryKeyType === 'uuid') { %>str<% } else { %>int<% } %>,
+    data: <%= it.entityName %>Update,
+    db: AsyncSession = Depends(get_db),
+) -> <%= it.entityName %>Schema:
+    """
+    Update an existing <%= it.entityName %>.
+    """
+    service = <%= it.entityName %>Service(db)
+    item = await service.update_one(id, data)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"<%= it.entityName %> with id {id} not found",
+        )
+    return item
+
+
+@router.put(
+    "/{id}",
+    response_model=<%= it.entityName %>Schema,
+    summary="Replace a single <%= it.entityName %>",
+)
+async def replace_one(
+    id: <% if (it.primaryKeyType === 'uuid') { %>str<% } else { %>int<% } %>,
+    data: <%= it.entityName %>Create,
+    db: AsyncSession = Depends(get_db),
+) -> <%= it.entityName %>Schema:
+    """
+    Replace an existing <%= it.entityName %>.
+    """
+    service = <%= it.entityName %>Service(db)
+    item = await service.replace_one(id, data)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"<%= it.entityName %> with id {id} not found",
+        )
+    return item
+
+
+@router.delete(
+    "/{id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Delete a single <%= it.entityName %>",
+)
+async def delete_one(
+    id: <% if (it.primaryKeyType === 'uuid') { %>str<% } else { %>int<% } %>,
+    db: AsyncSession = Depends(get_db),
+) -> None:
+    """
+    Delete a <%= it.entityName %> by ID.
+    """
+    service = <%= it.entityName %>Service(db)
+    deleted = await service.delete_one(id)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"<%= it.entityName %> with id {id} not found",
+        )

package/dist/lib/templates/python/schemas/schema-col-array.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[List[<%= it.field.arrayType === 'integer' ? 'int' : 'str' %>]] = None<% } else { %>List[<%= it.field.arrayType === 'integer' ? 'int' : 'str' %>]<% } %>

package/dist/lib/templates/python/schemas/schema-col-boolean.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[bool] = None<% } else { %>bool<% if (it.field.default !== undefined) { %> = <%= it.field.default %><% } %><% } %>

package/dist/lib/templates/python/schemas/schema-col-date.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[date] = None<% } else { %>date<% } %>

package/dist/lib/templates/python/schemas/schema-col-decimal.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[Decimal] = None<% } else { %>Decimal<% } %>

package/dist/lib/templates/python/schemas/schema-col-enum.eta

@@ -0,0 +1,6 @@
+<%
+// Generate the enum type name: EntityName + FieldNamePascal + Enum
+const fieldNamePascal = it.field.name.charAt(0).toUpperCase() + it.field.name.slice(1);
+const enumTypeName = it.field.enumType || `${it.entityName}${fieldNamePascal}Enum`;
+-%>
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[enums.<%= enumTypeName %>] = None<% } else { %>enums.<%= enumTypeName %><% } %>

package/dist/lib/templates/python/schemas/schema-col-float.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[float] = None<% } else { %>float<% } %>

package/dist/lib/templates/python/schemas/schema-col-integer.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[int] = None<% } else { %>int<% } %>

package/dist/lib/templates/python/schemas/schema-col-json.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[dict] = None<% } else { %>dict<% } %>

package/dist/lib/templates/python/schemas/schema-col-jsonb.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[dict] = None<% } else { %>dict<% } %>

package/dist/lib/templates/python/schemas/schema-col-numeric.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[Decimal] = None<% } else { %>Decimal<% } %>

package/dist/lib/templates/python/schemas/schema-col-string.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[str] = None<% } else { %>str = Field(max_length=<%= it.field.length || 255 %>)<% } %>

package/dist/lib/templates/python/schemas/schema-col-text.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[str] = None<% } else { %>str<% } %>

package/dist/lib/templates/python/schemas/schema-col-timestamp.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[datetime] = None<% } else { %>datetime<% } %>

package/dist/lib/templates/python/schemas/schema-col-timestamptz.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[datetime] = None<% } else { %>datetime<% } %>

package/dist/lib/templates/python/schemas/schema-col-uuid.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[UUID] = None<% } else { %>UUID<% } %>

package/dist/lib/templates/python/schemas/schema-col-varchar.eta

@@ -0,0 +1 @@
+    <%= it.field.name %>: <% if (!it.field.required || it.forUpdate) { %>Optional[str] = None<% } else { %>str = Field(max_length=<%= it.field.length || 255 %>)<% } %>

package/dist/lib/templates/python/schemas/schema.eta

@@ -0,0 +1,87 @@
+<%~ includeFile('../header.eta', it) %>
+
+from __future__ import annotations
+from typing import Optional, List, Any
+from datetime import datetime, date
+from decimal import Decimal
+from uuid import UUID
+from pydantic import BaseModel, Field, ConfigDict
+<% if (it.importEnums) { -%>
+from ..models import enums
+<% } -%>
+
+
+class <%= it.entityName %>Base(BaseModel):
+    """Base schema with common fields for <%= it.entityName %>"""
+<% it.columns.filter(c => !['id', 'createdAt', 'updatedAt', 'created_at', 'updated_at'].includes(c.name)).forEach((field) => { -%>
+<%~ includeFile(`./schema-col-${field.type}`, { field, entityName: it.entityName }) %>
+<% }); -%>
+
+<% /* Add foreign key fields for ManyToOne relationships */ -%>
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { -%>
+    <%= assoc.camelCasedId %>: Optional[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>UUID<% } else { %>int<% } %>] = None
+<% }); -%>
+
+
+class <%= it.entityName %>Create(BaseModel):
+    """Schema for creating a new <%= it.entityName %>"""
+<% it.columns.filter(c => !['id', 'createdAt', 'updatedAt', 'created_at', 'updated_at'].includes(c.name)).forEach((field) => { -%>
+<%~ includeFile(`./schema-col-${field.type}`, { field, entityName: it.entityName, forCreate: true }) %>
+<% }); -%>
+<% /* Add foreign key fields for ManyToOne relationships */ -%>
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { -%>
+    <%= assoc.camelCasedId %>: <% if (assoc.nullable) { %>Optional[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>UUID<% } else { %>int<% } %>] = None<% } else { %><% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>UUID<% } else { %>int<% } %><% } %>
+<% }); -%>
+
+
+class <%= it.entityName %>Update(BaseModel):
+    """Schema for updating an existing <%= it.entityName %>"""
+<% it.columns.filter(c => !['id', 'createdAt', 'updatedAt', 'created_at', 'updated_at'].includes(c.name)).forEach((field) => { -%>
+<%~ includeFile(`./schema-col-${field.type}`, { field, entityName: it.entityName, forUpdate: true }) %>
+<% }); -%>
+<% /* Add foreign key fields for ManyToOne relationships */ -%>
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { -%>
+    <%= assoc.camelCasedId %>: Optional[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>UUID<% } else { %>int<% } %>] = None
+<% }); -%>
+
+
+class <%= it.entityName %>(BaseModel):
+    """Full schema for <%= it.entityName %> including all fields"""
+    model_config = ConfigDict(from_attributes=True, populate_by_name=True)
+
+<% if (it.addDefaultPKProperty) { -%>
+<% if (it.primaryKeyType === 'uuid') { -%>
+    id: UUID
+<% } else { -%>
+    id: int
+<% } -%>
+<% } -%>
+<% if (it.createdAt) { -%>
+    createdAt: datetime = Field(alias="created_at")
+<% } -%>
+<% if (it.updatedAt) { -%>
+    updatedAt: datetime = Field(alias="updated_at")
+<% } -%>
+<% it.columns.filter(c => !['id', 'createdAt', 'updatedAt', 'created_at', 'updated_at'].includes(c.name)).forEach((field) => { -%>
+<%~ includeFile(`./schema-col-${field.type}`, { field, entityName: it.entityName }) %>
+<% }); -%>
+<% /* Add foreign key fields for ManyToOne relationships */ -%>
+<% it.associations.filter(a => a.type === 'ManyToOne').forEach((assoc) => { -%>
+    <%= assoc.camelCasedId %>: Optional[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>UUID<% } else { %>int<% } %>] = None
+<% }); -%>
+<% /* Add relationship fields */ -%>
+<% it.associations.filter(a => a.type === 'OneToMany' || a.type === 'ManyToMany').forEach((assoc) => { -%>
+    <%= assoc.pluralizedRelationshipName %>: Optional[List[Any]] = None
+<% }); -%>
+<% it.associations.filter(a => a.type === 'ManyToOne' || a.type === 'OneToOne').forEach((assoc) => { -%>
+    <%= assoc.relationshipName %>: Optional[Any] = None
+<% }); -%>
+
+
+class <%= it.entityName %>List(BaseModel):
+    """Paginated list response for <%= it.entityName %>"""
+    data: List[<%= it.entityName %>]
+    total: int
+    page: int
+    pageSize: int
+    totalPages: int

package/dist/lib/templates/python/services/service.eta

@@ -0,0 +1,163 @@
+<%~ includeFile('../header.eta', it) %>
+
+from typing import List, Optional, Tuple, Any, Dict
+from sqlalchemy import select, func, desc, asc
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from ..models.<%= it.entityName.toLowerCase() %> import <%= it.entityName %>
+from ..schemas.<%= it.entityName.toLowerCase() %> import <%= it.entityName %>Create, <%= it.entityName %>Update
+
+
+class <%= it.entityName %>Service:
+    """
+    Service layer for <%= it.entityName %> CRUD operations.
+    """
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_many(
+        self,
+        skip: int = 0,
+        limit: int = 10,
+        sort: Optional[str] = None,
+        filters: Optional[Dict[str, Any]] = None,
+        joins: Optional[List[str]] = None,
+    ) -> Tuple[List[<%= it.entityName %>], int]:
+        """
+        Retrieve a paginated list of <%= it.pluralEntityName %>.
+        """
+        # Build base query
+        query = select(<%= it.entityName %>)
+
+        # Apply filters
+        if filters:
+            for field, value in filters.items():
+                if hasattr(<%= it.entityName %>, field) and value is not None:
+                    query = query.where(getattr(<%= it.entityName %>, field) == value)
+
+        # Apply sorting
+        if sort:
+            if sort.startswith("-"):
+                query = query.order_by(desc(getattr(<%= it.entityName %>, sort[1:])))
+            else:
+                query = query.order_by(asc(getattr(<%= it.entityName %>, sort)))
+        else:
+            query = query.order_by(<%= it.entityName %>.id)
+
+        # Apply joins
+        if joins:
+            for join in joins:
+                if hasattr(<%= it.entityName %>, join):
+                    query = query.options(selectinload(getattr(<%= it.entityName %>, join)))
+
+        # Get total count
+        count_query = select(func.count()).select_from(<%= it.entityName %>)
+        if filters:
+            for field, value in filters.items():
+                if hasattr(<%= it.entityName %>, field) and value is not None:
+                    count_query = count_query.where(getattr(<%= it.entityName %>, field) == value)
+        total_result = await self.db.execute(count_query)
+        total = total_result.scalar() or 0
+
+        # Apply pagination
+        query = query.offset(skip).limit(limit)
+
+        # Execute query
+        result = await self.db.execute(query)
+        items = list(result.scalars().all())
+
+        return items, total
+
+    async def get_one(
+        self,
+        id: Any,
+        joins: Optional[List[str]] = None,
+    ) -> Optional[<%= it.entityName %>]:
+        """
+        Retrieve a single <%= it.entityName %> by ID.
+        """
+        query = select(<%= it.entityName %>).where(<%= it.entityName %>.id == id)
+
+        # Apply joins
+        if joins:
+            for join in joins:
+                if hasattr(<%= it.entityName %>, join):
+                    query = query.options(selectinload(getattr(<%= it.entityName %>, join)))
+
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def create_one(self, data: <%= it.entityName %>Create) -> <%= it.entityName %>:
+        """
+        Create a new <%= it.entityName %>.
+        """
+        item = <%= it.entityName %>(**data.model_dump(exclude_unset=True))
+        self.db.add(item)
+        await self.db.commit()
+        await self.db.refresh(item)
+        return item
+
+    async def create_many(self, data: List[<%= it.entityName %>Create]) -> List[<%= it.entityName %>]:
+        """
+        Create multiple <%= it.pluralEntityName %>.
+        """
+        items = [<%= it.entityName %>(**item.model_dump(exclude_unset=True)) for item in data]
+        self.db.add_all(items)
+        await self.db.commit()
+        for item in items:
+            await self.db.refresh(item)
+        return items
+
+    async def update_one(
+        self,
+        id: Any,
+        data: <%= it.entityName %>Update,
+    ) -> Optional[<%= it.entityName %>]:
+        """
+        Update an existing <%= it.entityName %>.
+        """
+        item = await self.get_one(id)
+        if not item:
+            return None
+
+        update_data = data.model_dump(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(item, field, value)
+
+        await self.db.commit()
+        await self.db.refresh(item)
+        return item
+
+    async def replace_one(
+        self,
+        id: Any,
+        data: <%= it.entityName %>Create,
+    ) -> Optional[<%= it.entityName %>]:
+        """
+        Replace an existing <%= it.entityName %>.
+        """
+        item = await self.get_one(id)
+        if not item:
+            return None
+
+        replace_data = data.model_dump()
+        for field, value in replace_data.items():
+            setattr(item, field, value)
+
+        await self.db.commit()
+        await self.db.refresh(item)
+        return item
+
+    async def delete_one(self, id: Any) -> bool:
+        """
+        Delete a <%= it.entityName %> by ID.
+        """
+        item = await self.get_one(id)
+        if not item:
+            return False
+
+        await self.db.delete(item)
+        await self.db.commit()
+        return True

package/dist/lib/templates/rest/controller-rest.eta

@@ -1,9 +1,9 @@
 <%~ includeFile('./header.eta') %>
 
-import { Controller } from "@nestjs/common";
+import { Controller, Body } from "@nestjs/common";
 import { Crud, CrudController, Override, ParsedRequest, CrudRequest, ParsedBody, CreateManyDto } from '@nestjsx/crud';
 import { ApiTags, ApiResponse, ApiOperation, ApiBody } from '@nestjs/swagger';
-import {<%= it.entityName %>, <%= it.entityName %>Create} from './dtos/<%= it.entityName%>.dto'
+import {<%= it.entityName %>, <%= it.entityName %>Create, <%= it.entityName %>Update} from './dtos/<%= it.entityName%>.dto'
 import {<%= it.svcName %>} from './<%= it.entityName %>.service';
   
 @Crud({
@@ -12,9 +12,10 @@ import {<%= it.svcName %>} from './<%= it.entityName %>.service';
     },
     dto: {
         create: <%= it.entityName %>Create,
-        update: <%= it.entityName %>,
-        replace: <%= it.entityName %>,
+        update: <%= it.entityName %>Update,
+        replace: <%= it.entityName %>Update,
     },
+    validation: false,
     params: {
         id: {
             field: 'id',
@@ -134,36 +135,36 @@ export class <%= it.ctrlName %> implements CrudController<<%= it.entityName %>>{
     })
     create(
         @ParsedRequest() req: CrudRequest,
-        @ParsedBody() dto: <%= it.entityName %>,
+        @Body() dto: <%= it.entityName %>Create,
     ) {
-        return this.base.createOneBase(req, dto);
+        return this.base.createOneBase(req, dto as unknown as <%= it.entityName %>);
     }
 
     @Override('createManyBase')
     @ApiOperation({ summary: 'Create multiple<%= it.pluralEntityName %>' })
     createMany(
         @ParsedRequest() req: CrudRequest,
-        @ParsedBody() dto: CreateManyDto<<%= it.entityName %>>
+        @Body() dto: CreateManyDto<<%= it.entityName %>Create>
     ) {
-        return this.base.createManyBase(req, dto);
+        return this.base.createManyBase(req, dto as unknown as CreateManyDto<<%= it.entityName %>>);
     }
 
     @Override('updateOneBase')
     @ApiOperation({ summary: 'Update a single <%= it.entityName %>' })
     update(
         @ParsedRequest() req: CrudRequest,
-        @ParsedBody() dto: <%= it.entityName %>,
+        @Body() dto: <%= it.entityName %>Update,
     ) {
-        return this.base.updateOneBase(req, dto);
+        return this.base.updateOneBase(req, dto as unknown as <%= it.entityName %>);
     }
 
     @Override('replaceOneBase')
     @ApiOperation({ summary: 'Replace a single <%= it.entityName %>' })
     replace(
         @ParsedRequest() req: CrudRequest,
-        @ParsedBody() dto: <%= it.entityName %>,
+        @Body() dto: <%= it.entityName %>Update,
     ) {
-        return this.base.replaceOneBase(req, dto);
+        return this.base.replaceOneBase(req, dto as unknown as <%= it.entityName %>);
     }
 
     @Override('deleteOneBase')