storm-cli 1.0.0__py3-none-any.whl

src/__init__.py

@@ -0,0 +1,2 @@
+# storm-cli  —  API Starter Kit
+# Core package: declarative schema → full-stack API code generation

src/ast.py

@@ -0,0 +1,100 @@
+import enum
+
+from src.error_handler import raise_error
+
+
+class AstType(enum.Enum):
+    IDENTIFIER = "identifier"
+    INT_LITERAL = "int_literal"
+    NUM_LITERAL = "num_literal"
+    STR_LITERAL = "str_literal"
+    BOOL_LITERAL = "bool_literal"
+    UNARY_NOT = "unary_not"
+    UNARY_BITWISE_NOT = "unary_bitwise_not"
+    UNARY_PLUS = "unary_plus"
+    UNARY_MINUS = "unary_minus"
+    BINARY_MUL = "binary_mul"
+    BINARY_DIV = "binary_div"
+    BINARY_MOD = "binary_mod"
+    BINARY_ADD = "binary_add"
+    BINARY_SUB = "binary_sub"
+    BINARY_SHL = "binary_shl"
+    BINARY_SHR = "binary_shr"
+    BINARY_LT = "binary_lt"
+    BINARY_LTE = "binary_lte"
+    BINARY_GT = "binary_gt"
+    BINARY_GTE = "binary_gte"
+    BINARY_EQ = "binary_eq"
+    BINARY_NE = "binary_ne"
+    BINARY_BITWISE_AND = "binary_bitwise_and"
+    BINARY_BITWISE_XOR = "binary_bitwise_xor"
+    BINARY_BITWISE_OR = "binary_bitwise_or"
+    BINARY_LOGICAL_AND = "binary_logical_and"
+    BINARY_LOGICAL_OR = "binary_logical_or"
+    PROGRAM = "program"
+    ENUM_DECL = "enum_decl"
+    ENUM_ITEM = "enum_item"
+    TABLE_DECL = "table_decl"
+    FIELD_DECL = "field_decl"
+    TYPE = "type"
+    FIELD_ATTRS = "field_attrs"
+    FIELD_ATTR = "field_attr"
+
+
+class ASTNode:
+    def __init__(self, node_type, position):
+        self.node_type = node_type
+        self.position = position
+        self.value: str = ""
+        self.a = None
+        self.b = None
+        self.c = None
+        self.d = None
+        self.next = None
+
+    @staticmethod
+    def create_terminal_node(type: AstType, value: str, position):
+        node = ASTNode(type, position)
+        node.value = value
+        return node
+
+    @staticmethod
+    def create_program(position):
+        return ASTNode(AstType.PROGRAM, position)
+
+    @staticmethod
+    def create_enum_decl(position):
+        return ASTNode(AstType.ENUM_DECL, position)
+
+    @staticmethod
+    def create_enum_item(position):
+        return ASTNode(AstType.ENUM_ITEM, position)
+
+    @staticmethod
+    def create_table_decl(position):
+        return ASTNode(AstType.TABLE_DECL, position)
+
+    @staticmethod
+    def create_field_decl(position):
+        return ASTNode(AstType.FIELD_DECL, position)
+
+    @staticmethod
+    def create_field_attrs(position):
+        return ASTNode(AstType.FIELD_ATTRS, position)
+
+    @staticmethod
+    def create_field_attr(position):
+        return ASTNode(AstType.FIELD_ATTR, position)
+
+    @staticmethod
+    def create_binary(op_type: AstType, left, right, position):
+        node = ASTNode(op_type, position)
+        node.a = left
+        node.b = right
+        return node
+
+    @staticmethod
+    def create_unary(op_type: AstType, operand, position):
+        node = ASTNode(op_type, position)
+        node.a = operand
+        return node

src/column.py

@@ -0,0 +1,56 @@
+
+
+
+PRIMITIVE_TYPES = {'int', 'long', 'float', 'double', 'string', 'bool', 'uuid', 'datetime'}
+
+
+class ColumnType:
+    def __init__(self, name: str, attrs=None, is_nullable=False, default_value=None):
+        self.name = name
+        self.is_nullable = is_nullable
+        self.attributes = attrs or {}
+        self.is_fk = False
+        self.ref_table = None
+        self.default_value = default_value
+        self.default_value_node = None
+
+    def to_csharp(self):
+        raise Exception("override")
+
+    def to_php(self):
+        raise Exception("override")
+
+    @classmethod
+    def from_ast(cls, type_node, table_names=None):
+        table_names = table_names or set()
+        type_name = type_node.value
+        attrs_node = type_node.a
+
+        attrs = {}
+        if attrs_node:
+            cur = attrs_node.a
+            while cur:
+                val = cur.b.value
+                try:
+                    val = int(val)
+                except ValueError:
+                    pass
+                attrs[cur.a.value] = val
+                cur = cur.next
+
+        is_nullable = type_name.endswith('?')
+        base_name = type_name[:-1] if is_nullable else type_name
+
+        if base_name in PRIMITIVE_TYPES:
+            return ColumnType(base_name, attrs, is_nullable)
+
+        col = cls(base_name, attrs, is_nullable)
+        if base_name in table_names:
+            col.is_fk = True
+            col.ref_table = base_name
+        return col
+
+
+class Int(ColumnType):
+    def __init__(self, min=None, max=None):
+        super().__init__("int", {"min": min or -2147483648, "max": max or 2147483647})

src/enum.py

@@ -0,0 +1,21 @@
+
+
+
+
+class Enum:
+    def __init__(self, name, keyValue):
+        self.name = name
+        self.keyValue = keyValue
+
+    @classmethod
+    def from_ast(cls, node):
+        name = node.a.value
+        items = []
+        cur = node.b
+        while cur:
+            value = cur.b.value if cur.b else None
+            items.append((cur.a.value, value))
+            cur = cur.next
+        return cls(name, items)
+
+

src/error_handler.py

@@ -0,0 +1,35 @@
+import sys
+
+
+def raise_error(file_path, file_data, message, pos):
+    PADDING = 4
+    lines = file_data.splitlines()
+    line_idx = pos.line - 1
+    col = pos.column - 1
+
+    buf = []
+    buf.append(f"Error: {message}")
+    buf.append(f" --> {file_path}:{pos.line}:{pos.column}")
+    buf.append("")
+
+    if 0 <= line_idx < len(lines):
+        context_before = 2
+        context_after = 2
+        start = max(0, line_idx - context_before)
+        end = min(len(lines), line_idx + context_after + 1)
+
+        for i in range(start, end):
+            line_num = i + 1
+            buf.append(f"{line_num:>{PADDING}} | {lines[i]}")
+
+            if i == line_idx:
+                indent = " " * (PADDING + 3)
+                col_clamped = max(0, min(col, len(lines[i])))
+                pointer = " " * col_clamped + "^"
+                remaining = len(lines[i]) - col_clamped
+                if remaining > 1:
+                    pointer += "~" * min(remaining - 1, 5)
+                buf.append(f"{indent}{pointer}")
+
+    sys.stdout.write("\n".join(buf) + "\n")
+    sys.exit(1)

src/generic_controller_csharp.py

@@ -0,0 +1,106 @@
+
+
+
+GENERIC_CONTROLLER_CSHARP = """\
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using $$config_iservice_path$$;
+using $$config_dto_path$$;
+using $$config_mapper_path$$;
+using $$config_pagination_path$$;
+
+namespace $$config_controller_path$$;
+
+[ApiController]
+[Route("api/[controller]")]
+public class GenericController<TEntity, TDto, TRequestDto, TKey> : ControllerBase
+    where TEntity : class
+    where TDto : class
+    where TRequestDto : class
+{
+    protected readonly IGenericService<TEntity, TDto, TRequestDto, TKey> _service;
+
+    public GenericController(IGenericService<TEntity, TDto, TRequestDto, TKey> service)
+    {
+        _service = service;
+    }
+}
+"""
+
+GENERIC_CONTROLLER_TEMPLATE_CSHARP = """\
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using $$config_iservice_path$$;
+using $$config_dto_path$$;
+using $$config_mapper_path$$;
+using $$config_pagination_path$$;
+
+namespace $$config_controller_path$$;
+
+[ApiController]
+[Route("api/[controller]")]
+public class GenericController<TEntity, TDto, TKey> : GenericController<$Entity$, $TDto$, $TRequestDto$, $TKey$>
+    where TEntity : class
+    where TDto : class
+{
+    [HttpGet("{id}", Name = "Get$Entity$ById")]
+    [Tags("$Entity$")]
+    [EndpointSummary("Retrieve by id")]
+    [EndpointDescription("Returns a single record by its unique identifier")]
+    [ProducesResponseType(typeof($TDto$), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public virtual async Task<ActionResult<$TDto$>> Show([FromRoute] $TKey$ id)
+    {
+        var result = await _service.GetByIdAsync(id);
+        return Ok(result);
+    }
+
+    [HttpGet(Name = "Get$Entity$Paginated")]
+    [Tags("$Entity$")]
+    [EndpointSummary("Paginated list")]
+    [EndpointDescription("Returns a paginated list of records")]
+    [ProducesResponseType(typeof(PaginatedResult<$TDto$>), StatusCodes.Status200OK)]
+    public virtual async Task<ActionResult<PaginatedResult<$TDto$>>> Index([FromQuery] PaginateQuery query)
+    {
+        var result = await _service.PaginateAsync(query);
+        return Ok(result);
+    }
+
+    [HttpPost(Name = "Create$Entity$")]
+    [Tags("$Entity$")]
+    [EndpointSummary("Create new")]
+    [EndpointDescription("Creates a new record from the provided payload")]
+    [ProducesResponseType(typeof($TDto$), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public virtual async Task<ActionResult<$TDto$>> Store([FromBody] $TRequestDto$ item)
+    {
+        var result = await _service.CreateAsync(item);
+        return Ok(result);
+    }
+
+    [HttpPut("{id}", Name = "Update$Entity$")]
+    [Tags("$Entity$")]
+    [EndpointSummary("Update by id")]
+    [EndpointDescription("Updates an existing record identified by its id with the provided payload")]
+    [ProducesResponseType(typeof($TDto$), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public virtual async Task<ActionResult<$TDto$>> Update([FromRoute] $TKey$ id, [FromBody] $TRequestDto$ item)
+    {
+        var result = await _service.UpdateAsync(id, item);
+        return Ok(result);
+    }
+
+    [HttpDelete("{id}", Name = "Delete$Entity$")]
+    [Tags("$Entity$")]
+    [EndpointSummary("Delete by id")]
+    [EndpointDescription("Deletes a record by its unique identifier")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public virtual async Task<IActionResult> Destroy([FromRoute] $TKey$ id)
+    {
+        await _service.DeleteAsync(id);
+        return NoContent();
+    }
+}
+"""

src/generic_mapper_csharp.py

@@ -0,0 +1,35 @@
+GENERIC_MAPPER_CSHARP = """\
+using AutoMapper;
+using $$config_model_path$$;
+using $$config_dto_path$$;
+
+namespace $$config_mapper_path$$;
+
+public class GenericMappingProfile<TEntity, TDto> : Profile
+    where TEntity : class
+    where TDto : class
+{
+    public GenericMappingProfile()
+    {
+        CreateMap<TEntity, TDto>().ReverseMap();
+    }
+}
+"""
+
+GENERIC_MAPPER_TEMPLATE_CSHARP = """\
+using AutoMapper;
+using $$config_model_path$$;
+using $$config_dto_path$$;
+
+namespace $$config_mapper_path$$;
+
+public class $$Entity$$MappingProfile : Profile
+{
+    public $$Entity$$MappingProfile()
+    {
+        CreateMap<$$TRequestDto$$, $$Entity$$>();
+        CreateMap<$$Entity$$, $$TResponseDto$$>();
+        CreateMap<$$Entity$$, $$TResponseDtoSimplified$$>();
+    }
+}
+"""

src/generic_pagination_csharp.py

@@ -0,0 +1,44 @@
+
+
+
+
+GENERIC_PAGINATION_CSHARP = """\
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+
+namespace $$config_pagination_path$$;
+
+public class PaginatedResult<T>
+{
+    public List<T> Items { get; set; } = new();
+    public int TotalCount { get; set; }
+    public int Page { get; set; }
+    public int Rows { get; set; }
+    public int TotalPages => (int)Math.Ceiling((double)TotalCount / Rows);
+    public bool HasPreviousPage => Page > 1;
+    public bool HasNextPage => Page < TotalPages;
+}
+
+public static class PaginationExtensions
+{
+    public static async Task<PaginatedResult<T>> PaginateAsync<T>(
+        this IQueryable<T> query, int page = 1, int rows = 20)
+    {
+        var totalCount = await query.CountAsync();
+        var items = await query
+            .Skip((page - 1) * rows)
+            .Take(rows)
+            .ToListAsync();
+        return new PaginatedResult<T>
+        {
+            Items = items,
+            TotalCount = totalCount,
+            Page = page,
+            Rows = rows
+        };
+    }
+}
+"""

src/generic_query_chsarp.py

@@ -0,0 +1,18 @@
+
+
+
+
+
+GENERIC_QUERY_CSHARP = """\
+
+namespace $$config_pagination_path$$;
+
+public class PaginateQuery
+{
+    public string? Search { get; set; }
+
+    public int Page { get; set; } = 1;
+
+    public int Rows { get; set; } = 20;
+}
+"""

src/generic_service_csharp.py

@@ -0,0 +1,112 @@
+
+
+
+GENERIC_ISERVICE_CSHARP = """\
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using $$config_dto_path$$;
+using $$config_pagination_path$$;
+
+namespace $$config_iservice_path$$;
+
+public interface IGenericService<TEntity, TDto, TRequestDto, TKey>
+    where TEntity : class
+    where TDto : class
+    where TRequestDto : class
+{
+    public Task<TDto> GetByIdAsync(TKey id);
+    public Task<PaginatedResult<TDto>> PaginateAsync(PaginateQuery query);
+    public Task<TDto> CreateAsync(TRequestDto item);
+    public Task<TDto> UpdateAsync(TKey id, TRequestDto item);
+    public Task DeleteAsync(TKey id);
+}
+"""
+
+
+GENERIC_SERVICE_CSHARP = """\
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+using $$config_iservice_path$$;
+using $$config_model_path$$;
+using $$config_dto_path$$;
+using $$config_mapper_path$$;
+using $$config_pagination_path$$;
+
+namespace $$config_service_path$$;
+
+public class GenericService<TEntity, TDto, TRequestDto, TKey> : IGenericService<TEntity, TDto, TRequestDto, TKey>
+    where TEntity : class
+    where TDto : class
+    where TRequestDto : class
+{
+    protected readonly DbContext _context;
+    protected readonly DbSet<TEntity> _table;
+    protected readonly IMapper _mapper;
+
+    public GenericService(DbContext context, IMapper mapper)
+    {
+        _context = context;
+        _table = context.Set<TEntity>();
+        _mapper = mapper;
+    }
+
+    public virtual async Task<TDto> GetByIdAsync(TKey id)
+    {
+        var entity = await _table.FindAsync(id);
+        if (entity == null)
+            throw new KeyNotFoundException($"{typeof(TEntity).Name} with id {id} not found");
+        return _mapper.Map<TDto>(entity);
+    }
+
+    public virtual async Task<PaginatedResult<TDto>> PaginateAsync(PaginateQuery query)
+    {
+        var q = _table.AsQueryable();
+        var totalCount = await q.CountAsync();
+        var items = await q
+            .Skip((query.Page - 1) * query.Rows)
+            .Take(query.Rows)
+            .ProjectTo<TDto>(_mapper.ConfigurationProvider)
+            .ToListAsync();
+        return new PaginatedResult<TDto>
+        {
+            Items = items,
+            TotalCount = totalCount,
+            Page = query.Page,
+            Rows = query.Rows
+        };
+    }
+
+    public virtual async Task<TDto> CreateAsync(TRequestDto item)
+    {
+        var entity = _mapper.Map<TEntity>(item);
+        _table.Add(entity);
+        await _context.SaveChangesAsync();
+        return _mapper.Map<TDto>(entity);
+    }
+
+    public virtual async Task<TDto> UpdateAsync(TKey id, TRequestDto item)
+    {
+        var entity = await _table.FindAsync(id);
+        if (entity == null)
+            throw new KeyNotFoundException($"{typeof(TEntity).Name} with id {id} not found");
+        _mapper.Map(item, entity);
+        await _context.SaveChangesAsync();
+        return _mapper.Map<TDto>(entity);
+    }
+
+    public virtual async Task DeleteAsync(TKey id)
+    {
+        var entity = await _table.FindAsync(id);
+        if (entity == null)
+            throw new KeyNotFoundException($"{typeof(TEntity).Name} with id {id} not found");
+        _table.Remove(entity);
+        await _context.SaveChangesAsync();
+    }
+}
+"""