@apso/cli 0.7.4 → 0.8.2

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

@@ -0,0 +1,190 @@
+<%~ includeFile('../../header.eta', it) %>
+
+package services
+
+import (
+	"context"
+	"errors"
+
+	"app/dto"
+	"app/models"
+	"gorm.io/gorm"
+)
+
+type <%= it.entityName %>Service struct {
+	db *gorm.DB
+}
+
+func New<%= it.entityName %>Service(db *gorm.DB) *<%= it.entityName %>Service {
+	return &<%= it.entityName %>Service{db: db}
+}
+
+// FindAll retrieves a paginated list of <%= it.pluralName %>
+func (s *<%= it.entityName %>Service) FindAll(ctx context.Context, page, pageSize int) (*dto.<%= it.entityName %>PaginatedResponse, error) {
+	var total int64
+	var items []models.<%= it.entityName %>
+
+	offset := (page - 1) * pageSize
+
+	if err := s.db.WithContext(ctx).Model(&models.<%= it.entityName %>{}).Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	query := s.db.WithContext(ctx)
+<% it.associations.filter(a => a.eager).forEach((assoc) => { %>
+	query = query.Preload("<%= assoc.referenceName || assoc.name %>")
+<% }) %>
+	if err := query.Offset(offset).Limit(pageSize).Find(&items).Error; err != nil {
+		return nil, err
+	}
+
+	totalPages := int(total) / pageSize
+	if int(total)%pageSize > 0 {
+		totalPages++
+	}
+
+	response := make([]dto.<%= it.entityName %>Response, len(items))
+	for i, item := range items {
+		response[i] = s.toResponse(&item)
+	}
+
+	return &dto.<%= it.entityName %>PaginatedResponse{
+		Data:       response,
+		Total:      total,
+		Page:       page,
+		PageSize:   pageSize,
+		TotalPages: totalPages,
+	}, nil
+}
+
+// FindOne retrieves a single <%= it.entityName %> by ID
+func (s *<%= it.entityName %>Service) FindOne(ctx context.Context, id string) (*dto.<%= it.entityName %>Response, error) {
+	var item models.<%= it.entityName %>
+
+	query := s.db.WithContext(ctx)
+<% it.associations.filter(a => a.eager).forEach((assoc) => { %>
+	query = query.Preload("<%= assoc.referenceName || assoc.name %>")
+<% }) %>
+
+<% if (it.primaryKeyType === 'uuid') { %>
+	if err := query.Where("id = ?", id).First(&item).Error; err != nil {
+<% } else { %>
+	if err := query.First(&item, id).Error; err != nil {
+<% } %>
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("<%= it.entityName %> not found")
+		}
+		return nil, err
+	}
+
+	response := s.toResponse(&item)
+	return &response, nil
+}
+
+// Create creates a new <%= it.entityName %>
+func (s *<%= it.entityName %>Service) Create(ctx context.Context, input *dto.<%= it.entityName %>Create) (*dto.<%= it.entityName %>Response, error) {
+	item := models.<%= it.entityName %>{
+<% it.columns.filter(c => !c.generated && !c.primary).forEach((column) => { %>
+<% if (column.required) { %>
+		<%= column.pascalName %>: input.<%= column.pascalName %>,
+<% } else { %>
+		<%= column.pascalName %>: input.<%= column.pascalName %>,
+<% } %>
+<% }) %>
+<% it.associations.filter(a => a.type === 'ManyToOne' || (a.type === 'OneToOne' && a.isOwner)).forEach((assoc) => { %>
+		<%= assoc.referenceName || assoc.name %>ID: input.<%= assoc.referenceName || assoc.name %>ID,
+<% }) %>
+	}
+
+	if err := s.db.WithContext(ctx).Create(&item).Error; err != nil {
+		return nil, err
+	}
+
+	response := s.toResponse(&item)
+	return &response, nil
+}
+
+// Update updates an existing <%= it.entityName %>
+func (s *<%= it.entityName %>Service) Update(ctx context.Context, id string, input *dto.<%= it.entityName %>Update) (*dto.<%= it.entityName %>Response, error) {
+	var item models.<%= it.entityName %>
+
+<% if (it.primaryKeyType === 'uuid') { %>
+	if err := s.db.WithContext(ctx).Where("id = ?", id).First(&item).Error; err != nil {
+<% } else { %>
+	if err := s.db.WithContext(ctx).First(&item, id).Error; err != nil {
+<% } %>
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("<%= it.entityName %> not found")
+		}
+		return nil, err
+	}
+
+	updates := make(map[string]interface{})
+<% it.columns.filter(c => !c.generated && !c.primary).forEach((column) => { %>
+	if input.<%= column.pascalName %> != nil {
+		updates["<%= column.snakeName %>"] = *input.<%= column.pascalName %>
+	}
+<% }) %>
+<% it.associations.filter(a => a.type === 'ManyToOne' || (a.type === 'OneToOne' && a.isOwner)).forEach((assoc) => { %>
+	if input.<%= assoc.referenceName || assoc.name %>ID != nil {
+		updates["<%= assoc.snakeReferenceName || assoc.snakeName %>_id"] = *input.<%= assoc.referenceName || assoc.name %>ID
+	}
+<% }) %>
+
+	if len(updates) > 0 {
+		if err := s.db.WithContext(ctx).Model(&item).Updates(updates).Error; err != nil {
+			return nil, err
+		}
+	}
+
+	// Reload with associations
+	query := s.db.WithContext(ctx)
+<% it.associations.filter(a => a.eager).forEach((assoc) => { %>
+	query = query.Preload("<%= assoc.referenceName || assoc.name %>")
+<% }) %>
+<% if (it.primaryKeyType === 'uuid') { %>
+	if err := query.Where("id = ?", id).First(&item).Error; err != nil {
+<% } else { %>
+	if err := query.First(&item, id).Error; err != nil {
+<% } %>
+		return nil, err
+	}
+
+	response := s.toResponse(&item)
+	return &response, nil
+}
+
+// Delete removes a <%= it.entityName %> by ID
+func (s *<%= it.entityName %>Service) Delete(ctx context.Context, id string) error {
+<% if (it.primaryKeyType === 'uuid') { %>
+	result := s.db.WithContext(ctx).Where("id = ?", id).Delete(&models.<%= it.entityName %>{})
+<% } else { %>
+	result := s.db.WithContext(ctx).Delete(&models.<%= it.entityName %>{}, id)
+<% } %>
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return errors.New("<%= it.entityName %> not found")
+	}
+	return nil
+}
+
+// toResponse converts a model to a response DTO
+func (s *<%= it.entityName %>Service) toResponse(item *models.<%= it.entityName %>) dto.<%= it.entityName %>Response {
+	return dto.<%= it.entityName %>Response{
+		ID: item.ID,
+<% it.columns.forEach((column) => { %>
+		<%= column.pascalName %>: item.<%= column.pascalName %>,
+<% }) %>
+<% if (it.createdAt) { %>
+		CreatedAt: item.CreatedAt,
+<% } %>
+<% if (it.updatedAt) { %>
+		UpdatedAt: item.UpdatedAt,
+<% } %>
+<% it.associations.filter(a => a.type === 'ManyToOne' || (a.type === 'OneToOne' && a.isOwner)).forEach((assoc) => { %>
+		<%= assoc.referenceName || assoc.name %>ID: item.<%= assoc.referenceName || assoc.name %>ID,
+<% }) %>
+	}
+}

package/dist/lib/templates/python/enums.eta

@@ -0,0 +1,10 @@
+<%~ includeFile('./header.eta', it) %>
+
+from enum import Enum
+<% for (const field of it.allEnumsFields) { %>
+
+class <%= field.name %>(str, Enum):
+<% for (const value of (field.values || [])) { %>
+    <%= value.toUpperCase().replace(/[^A-Z0-9_]/g, '_') %> = "<%= value %>"
+<% } %>
+<% } %>

package/dist/lib/templates/python/header.eta

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# Generated: <%= it.generatedAt %>
+
+# Auto-generated by Apso CLI
+# DO NOT EDIT - This file is managed by Apso and will be overwritten on scaffold
+

package/dist/lib/templates/python/index-module.eta

@@ -0,0 +1,18 @@
+<%~ includeFile('./header.eta', it) %>
+
+from fastapi import APIRouter
+
+<% it.entities.forEach((entity) => { %>
+from .routers.<%= entity.name.toLowerCase() %> import router as <%= entity.name.toLowerCase() %>_router
+<% }) %>
+
+# Create main router for autogenerated endpoints
+autogen_router = APIRouter(prefix="/api")
+
+# Include all entity routers
+<% it.entities.forEach((entity) => { %>
+autogen_router.include_router(<%= entity.name.toLowerCase() %>_router)
+<% }) %>
+
+# Export for use in main.py
+__all__ = ["autogen_router"]

package/dist/lib/templates/python/models/model-col-array.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[list]<% } else { %>list<% } %>] = mapped_column(
+        ARRAY(<%= it.field.arrayType === 'integer' ? 'Integer' : 'String' %>),
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-boolean.eta

@@ -0,0 +1,5 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[bool]<% } else { %>bool<% } %>] = mapped_column(
+        Boolean,
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.default !== undefined) { %>,
+        default=<%= it.field.default === true ? 'True' : (it.field.default === false ? 'False' : it.field.default) %><% } %>
+    )

package/dist/lib/templates/python/models/model-col-date.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[date]<% } else { %>date<% } %>] = mapped_column(
+        Date,
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-decimal.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[Decimal]<% } else { %>Decimal<% } %>] = mapped_column(
+        Numeric(precision=<%= it.field.precision || 10 %>, scale=<%= it.field.scale || 2 %>),
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-enum.eta

@@ -0,0 +1,16 @@
+<%
+// 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`;
+// Generate the PostgreSQL enum type name (snake_case version)
+const pgEnumName = (it.entityName + '_' + it.field.name + '_enum').toLowerCase().replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+-%>
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[enums.<%= enumTypeName %>]<% } else { %>enums.<%= enumTypeName %><% } %>] = mapped_column(
+        SAEnum(
+            enums.<%= enumTypeName %>,
+            name="<%= pgEnumName %>",
+            values_callable=lambda x: [e.value for e in x],
+            create_type=False
+        ),
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-float.eta

@@ -0,0 +1,5 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[float]<% } else { %>float<% } %>] = mapped_column(
+        Float,
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.default !== undefined) { %>,
+        default=<%= it.field.default %><% } %>
+    )

package/dist/lib/templates/python/models/model-col-integer.eta

@@ -0,0 +1,6 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[int]<% } else { %>int<% } %>] = mapped_column(
+        Integer,
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.unique) { %>,
+        unique=True<% } %><% if (it.field.default !== undefined) { %>,
+        default=<%= it.field.default %><% } %>
+    )

package/dist/lib/templates/python/models/model-col-json.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[dict]<% } else { %>dict<% } %>] = mapped_column(
+        JSON,
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-jsonb.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[dict]<% } else { %>dict<% } %>] = mapped_column(
+        JSONB,
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-numeric.eta

@@ -0,0 +1,4 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[Decimal]<% } else { %>Decimal<% } %>] = mapped_column(
+        Numeric(precision=<%= it.field.precision || 10 %>, scale=<%= it.field.scale || 2 %>),
+        nullable=<%= it.field.required ? 'False' : 'True' %>
+    )

package/dist/lib/templates/python/models/model-col-string.eta

@@ -0,0 +1,6 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[str]<% } else { %>str<% } %>] = mapped_column(
+        String(<%= it.field.length || 255 %>),
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.unique) { %>,
+        unique=True<% } %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
+        default=<%= JSON.stringify(it.field.default) %><% } %>
+    )

package/dist/lib/templates/python/models/model-col-text.eta

@@ -0,0 +1,6 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[str]<% } else { %>str<% } %>] = mapped_column(
+        Text,
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.unique) { %>,
+        unique=True<% } %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
+        default=<%= JSON.stringify(it.field.default) %><% } %>
+    )

package/dist/lib/templates/python/models/model-col-timestamp.eta

@@ -0,0 +1,11 @@
+<%
+const isCreatedAt = ['createdAt', 'created_at'].includes(it.field.name);
+const isUpdatedAt = ['updatedAt', 'updated_at'].includes(it.field.name);
+-%>
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[datetime]<% } else { %>datetime<% } %>] = mapped_column(
+        DateTime,
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (isCreatedAt) { %>,
+        server_default=func.now()<% } %><% if (isUpdatedAt) { %>,
+        server_default=func.now(),
+        onupdate=func.now()<% } %>
+    )

package/dist/lib/templates/python/models/model-col-timestamptz.eta

@@ -0,0 +1,11 @@
+<%
+const isCreatedAt = ['createdAt', 'created_at'].includes(it.field.name);
+const isUpdatedAt = ['updatedAt', 'updated_at'].includes(it.field.name);
+-%>
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[datetime]<% } else { %>datetime<% } %>] = mapped_column(
+        DateTime(timezone=True),
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (isCreatedAt) { %>,
+        server_default=func.now()<% } %><% if (isUpdatedAt) { %>,
+        server_default=func.now(),
+        onupdate=func.now()<% } %>
+    )

package/dist/lib/templates/python/models/model-col-uuid.eta

@@ -0,0 +1,5 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[UUID]<% } else { %>UUID<% } %>] = mapped_column(
+        PGUUID(as_uuid=True),
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.unique) { %>,
+        unique=True<% } %>
+    )

package/dist/lib/templates/python/models/model-col-varchar.eta

@@ -0,0 +1,6 @@
+    <%= it.field.name %>: Mapped[<% if (!it.field.required) { %>Optional[str]<% } else { %>str<% } %>] = mapped_column(
+        String(<%= it.field.length || 255 %>),
+        nullable=<%= it.field.required ? 'False' : 'True' %><% if (it.field.unique) { %>,
+        unique=True<% } %><% if (it.field.default !== undefined) { %>,
+        default="<%= it.field.default %>"<% } %>
+    )

package/dist/lib/templates/python/models/model.eta

@@ -0,0 +1,124 @@
+<%~ includeFile('../header.eta', it) %>
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, List
+from datetime import datetime, date
+from decimal import Decimal
+from uuid import UUID
+
+from sqlalchemy import Column, Integer, String, Text, Boolean, Float, Numeric, Date, DateTime, JSON, Enum as SAEnum, ForeignKey, Index, UniqueConstraint, Table
+from sqlalchemy.dialects.postgresql import UUID as PGUUID, JSONB, ARRAY, BYTEA, INET, INTERVAL, TSVECTOR
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+from sqlalchemy.sql import func
+
+from app.database import Base
+<% if (it.importEnums) { %>
+from . import enums
+<% } %>
+
+<% if (it.entitiesToImport && it.entitiesToImport.length > 0) { %>
+if TYPE_CHECKING:
+<% it.entitiesToImport.forEach((assocName) => { %>
+    from .<%= assocName.toLowerCase() %> import <%= assocName %>
+<% }) %>
+<% } %>
+
+<% /* Generate ManyToMany junction tables */ %>
+<% it.associations.filter(a => a.type === 'ManyToMany' && a.joinTable).forEach((assoc) => { %>
+<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %> = Table(
+    "<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %>",
+    Base.metadata,
+    Column("<%= assoc.joinColumnName || `${it.snakeCasedName}_id` %>", <% if (it.primaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= it.snakeCasedName %>.id"), primary_key=True),
+    Column("<%= assoc.inverseJoinColumnName || `${assoc.name.toLowerCase()}_id` %>", <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>, ForeignKey("<%= assoc.name.toLowerCase() %>.id"), primary_key=True),
+)
+<% }) %>
+
+class <%= it.name %>(Base):
+    """
+    SQLAlchemy model for <%= it.name %>
+    """
+    __tablename__ = "<%= it.snakeCasedName %>"
+
+<% /* Generate table arguments for indexes and unique constraints */ %>
+<% if ((it.indexes && it.indexes.length > 0) || (it.uniques && it.uniques.length > 0)) { %>
+    __table_args__ = (
+<% it.indexes.forEach((index) => { %>
+        Index("<%= index.name || `idx_${it.snakeCasedName}_${index.fields.join('_')}` %>", <%~ index.fields.map(f => `"${f}"`).join(', ') %><% if (index.unique) { %>, unique=True<% } %>),
+<% }) %>
+<% it.uniques.forEach((unique) => { %>
+        UniqueConstraint(<%~ unique.fields.map(f => `"${f}"`).join(', ') %><% if (unique.name) { %>, name="<%= unique.name %>"<% } %>),
+<% }) %>
+    )
+<% } %>
+
+    # Primary Key
+<% if (it.createPrimaryKey) { %>
+<% if (it.primaryKeyType === 'uuid') { %>
+    id: Mapped[UUID] = mapped_column(PGUUID(as_uuid=True), primary_key=True)
+<% } else { %>
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+<% } %>
+<% } %>
+
+<% /* Timestamp columns */ %>
+<% if (it.createdAt) { %>
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+<% } %>
+<% if (it.updatedAt) { %>
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+<% } %>
+
+    # Columns
+<%
+// Filter out id (if createPrimaryKey), createdAt, and updatedAt since they're handled separately
+const columnsToProcess = it.columns.filter(c => {
+  if (it.createPrimaryKey && c.name === 'id') return false;
+  if (it.createdAt && c.name === 'createdAt') return false;
+  if (it.updatedAt && c.name === 'updatedAt') return false;
+  return true;
+});
+columnsToProcess.forEach((field) => { -%>
+<%~ includeFile(`./model-col-${field.type}`, { field, entityName: it.name }) %>
+<% }); %>
+
+    # Relationships
+<% it.associations.forEach((assoc) => { %>
+<% if (assoc.type === 'OneToMany') { %>
+    <%= assoc.pluralizedRelationshipName %>: Mapped[List["<%= assoc.name %>"]] = relationship(
+        "<%= assoc.name %>",
+        back_populates="<%= assoc.inverseSidePropertyName %>",
+        lazy="selectin"
+    )
+<% } else if (assoc.type === 'ManyToOne') { %>
+    # Foreign key for <%= assoc.name %>
+    <%= assoc.camelCasedId %>: Mapped[<% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>Optional[UUID]<% } else { %>Optional[int]<% } %>] = mapped_column(
+        <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>PGUUID(as_uuid=True)<% } else { %>Integer<% } %>,
+        ForeignKey("<%= assoc.name.toLowerCase() %>.id"<% if (assoc.cascadeDelete) { %>, ondelete="CASCADE"<% } %>),
+        nullable=<%= assoc.nullable ? 'True' : 'False' %><% if (assoc.index) { %>,
+        index=True<% } %>
+    )
+    <%= assoc.relationshipName %>: Mapped[Optional["<%= assoc.name %>"]] = relationship(
+        "<%= assoc.name %>",
+        <% if (assoc.biDirectional) { %>back_populates="<%= assoc.inverseSidePropertyName %>",<% } %>
+        lazy="selectin"
+    )
+<% } else if (assoc.type === 'ManyToMany') { %>
+    <%= assoc.pluralizedRelationshipName %>: Mapped[List["<%= assoc.name %>"]] = relationship(
+        "<%= assoc.name %>",
+        secondary=<%= assoc.joinTableName || `${it.snakeCasedName}_${assoc.name.toLowerCase()}` %>,
+        <% if (assoc.biDirectional) { %>back_populates="<%= assoc.inverseSidePropertyName %>",<% } %>
+        lazy="selectin"
+    )
+<% } else if (assoc.type === 'OneToOne') { %>
+    <%= assoc.relationshipName %>: Mapped[Optional["<%= assoc.name %>"]] = relationship(
+        "<%= assoc.name %>",
+        <% if (assoc.biDirectional) { %>back_populates="<%= assoc.inverseSidePropertyName %>",<% } %>
+        uselist=False,
+        cascade="all, delete-orphan",
+        lazy="selectin"
+    )
+<% } %>
+<% }) %>
+
+    def __repr__(self) -> str:
+        return f"<<%= it.name %>(id={self.id})>"