belt 0.2.4 → 0.2.6

data/lib/belt/cli/generate_command.rb

@@ -39,8 +39,9 @@ module Belt
               lambda/models/<name>.rb                            Model with validations and fields
               lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
               config/routes.tf.rb                                Route entry added
-              config/schema.tf.rb                                DynamoDB table schema added
+              config/schema.tf.rb                                API response contract added
               lambda/lib/routes/<app>_routes.rb                  Route manifest updated
+              infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
               frontend/src/pages/<names>/                        React pages (if frontend exists)
 
             Alias: `belt g resource` works the same way.
@@ -58,7 +59,9 @@ module Belt
           ],
           notes: <<~NOTES
             Creates:
-              lambda/models/<name>.rb    Model class inheriting from ActiveItem::Base
+              lambda/models/<name>.rb                            Model class inheriting from ApplicationRecord
+              config/schema.tf.rb                                API response contract added
+              infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
           NOTES
         },
         'controller' => {
@@ -452,11 +455,12 @@ module Belt
 
         content = File.read(schema_file)
 
-        field_lines = @fields.map { |f| "    field :#{f[:name]}, type: :#{f[:type]}" }
-        field_lines << '    field :created_at, type: :string'
-        field_lines << '    field :updated_at, type: :string'
+        # Generate OpenAPI-style model block for API response contracts
+        response_fields = @fields.map { |f| "    #{schema_type_for(f[:type])} :#{f[:name]}" }
+        response_fields << '    string :created_at'
+        response_fields << '    string :updated_at'
 
-        schema_block = "  model :#{@singular_name} do\n#{field_lines.join("\n")}\n  end\n"
+        schema_block = "  model :#{@singular_name} do\n#{response_fields.join("\n")}\n  end\n"
 
         # If model already exists (force mode), replace it
         existing_model_pattern = /^  model :#{Regexp.escape(@singular_name)} do\n.*?^  end\n/m
@@ -474,6 +478,18 @@ module Belt
         puts "  update  #{schema_file}"
       end
 
+      # Map generator field types to OpenAPI schema DSL types
+      def schema_type_for(field_type)
+        case field_type.to_s
+        when 'text' then 'string'
+        when 'integer' then 'integer'
+        when 'float' then 'number'
+        when 'boolean' then 'boolean'
+        when 'date', 'datetime' then 'string'
+        else 'string'
+        end
+      end
+
       def sync_tables
         Belt::CLI::TablesCommand.sync_all_environments
       end

data/lib/belt/cli/tables_command.rb

@@ -7,8 +7,8 @@ require_relative '../inflector'
 module Belt
   module CLI
     class TablesCommand
-      SCHEMA_FILE_CANDIDATES = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb'].freeze
       MODULE_DIR = 'infrastructure/modules/app'
+      MODELS_DIR = 'lambda/models'
 
       def self.run(args)
         # Environment argument accepted for backwards compatibility but unused —
@@ -19,26 +19,22 @@ module Belt
       end
 
       # Automatically sync dynamodb.tf in the app module.
-      # Called by generators after updating schema.tf.rb.
+      # Called by generators after creating/updating model files.
       def self.sync_all_environments
-        return unless schema_file_path
+        return unless Dir.exist?(MODELS_DIR)
 
         new(quiet: true).run
       end
 
-      def self.schema_file_path
-        SCHEMA_FILE_CANDIDATES.find { |f| File.exist?(f) }
-      end
-
       def initialize(quiet: false)
         @quiet = quiet
       end
 
       def run
         validate!
-        models = parse_schema
+        models = parse_models
         if models.empty?
-          puts "No models found in #{SCHEMA_FILE}" unless @quiet
+          puts "No models found in #{MODELS_DIR}/" unless @quiet
           return
         end
 
@@ -48,11 +44,10 @@ module Belt
       private
 
       def validate!
-        schema_file = self.class.schema_file_path
-        unless schema_file
+        unless Dir.exist?(MODELS_DIR)
           unless @quiet
-            abort 'Error: No schema.tf.rb found (checked config/ and infrastructure/). ' \
-                  'Run `belt generate resource` first.'
+            abort "Error: No models directory found at #{MODELS_DIR}/. " \
+                  'Run `belt generate model` to create your first model.'
           end
           return
         end
@@ -64,21 +59,53 @@ module Belt
               'Run `belt new` to create a project with the correct structure.'
       end
 
-      def parse_schema
-        schema_file = self.class.schema_file_path
-        return [] unless schema_file && File.exist?(schema_file)
+      def parse_models
+        model_files = Dir.glob(File.join(MODELS_DIR, '*.rb'))
+                        .reject { |f| File.basename(f) == 'application_record.rb' }
+                        .reject { |f| File.basename(f).start_with?('concerns') }
+                        .sort
+
+        model_files.filter_map { |f| parse_model_file(f) }
+      end
+
+      # Parse a model file to extract its name and index declarations.
+      # Uses lightweight regex parsing — does NOT require loading activeitem or the model.
+      def parse_model_file(file_path)
+        content = File.read(file_path)
 
-        parser = SchemaParser.new
-        schema_content = File.read(schema_file)
+        # Extract class name from `class Foo < ApplicationRecord`
+        class_match = content.match(/^class\s+(\w+)\s*<\s*ApplicationRecord/)
+        return nil unless class_match
 
-        # Replace DSL wrapper with direct parser call
-        inner = schema_content.sub(/\A(?:Belt\.application)\.schema\.draw do\n?/, '').sub(/\n?end\s*\z/, '')
-        inner.strip!
+        class_name = class_match[1]
+        model_name = Belt::Inflector.underscore(class_name)
 
-        return [] if inner.empty? || inner.match?(/\A\s*\z/m)
+        # Extract indexes() declaration
+        indexes = extract_indexes(content)
 
-        parser.instance_eval(inner, schema_file)
-        parser.models
+        { name: model_name, indexes: indexes }
+      end
+
+      def extract_indexes(content)
+        indexes = []
+
+        # Match the indexes() DSL: indexes('Name' => { partition_key: 'pk' }, ...)
+        # This handles the Ruby hash syntax used by ActiveItem
+        index_block = content.match(/^\s*indexes\(\s*\n?(.*?)\n?\s*\)/m)
+        return indexes unless index_block
+
+        index_content = index_block[1]
+
+        # Parse each index entry: 'IndexName' => { partition_key: 'key', sort_key: 'key' }
+        index_content.scan(/'([^']+)'\s*=>\s*\{([^}]+)\}/) do |name, opts|
+          partition_key = opts.match(/partition_key:\s*'([^']+)'/)&.captures&.first
+          sort_key = opts.match(/sort_key:\s*'([^']+)'/)&.captures&.first
+          next unless partition_key
+
+          indexes << { name: name, partition_key: partition_key, sort_key: sort_key }
+        end
+
+        indexes
       end
 
       def generate_dynamodb_tf(models)
@@ -104,78 +131,94 @@ module Belt
 
       def render_dynamodb(models)
         blocks = models.map { |m| render_table(m) }
-        "# Auto-generated by Belt from schema.tf.rb\n" \
+        "# Auto-generated by Belt from model definitions\n" \
           "# Do not edit manually — re-run `belt setup tables`\n\n#{blocks.join("\n\n")}\n"
       end
 
       def render_table(model)
         name = table_name(model[:name])
-        <<~HCL
-          resource "aws_dynamodb_table" "#{Belt::Inflector.pluralize(model[:name])}" {
-            name         = "#{name}"
-            billing_mode = "PAY_PER_REQUEST"
-            hash_key     = "id"
-
-            attribute {
-              name = "id"
-              type = "S"
-            }
-
-            attribute {
-              name = "_recent_pk"
-              type = "S"
-            }
-
-            attribute {
-              name = "createdAt"
-              type = "S"
-            }
-
-            global_secondary_index {
-              name            = "RecentIndex"
-              hash_key        = "_recent_pk"
-              range_key       = "createdAt"
-              projection_type = "ALL"
-            }
-
-            tags = {
-              Name        = "#{name}"
-              Environment = var.environment
-              ManagedBy   = "Terraform"
-            }
-          }
-        HCL
-      end
-
-      def table_name(model_name)
-        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
-      end
-
-      # Minimal DSL parser for schema.tf.rb
-      class SchemaParser
-        attr_reader :models
-
-        def initialize
-          @models = []
+        custom_indexes = model[:indexes] || []
+
+        # Collect all custom index attribute names, deduplicating against built-in ones
+        builtin_attrs = Set.new(%w[id _recent_pk createdAt])
+        extra_attrs = []
+        custom_indexes.each do |idx|
+          unless builtin_attrs.include?(idx[:partition_key])
+            extra_attrs << idx[:partition_key]
+            builtin_attrs.add(idx[:partition_key])
+          end
+          if idx[:sort_key] && !builtin_attrs.include?(idx[:sort_key])
+            extra_attrs << idx[:sort_key]
+            builtin_attrs.add(idx[:sort_key])
+          end
         end
 
-        def model(name, &block)
-          model_def = ModelParser.new
-          model_def.instance_eval(&block) if block
-          @models << { name: name.to_s, fields: model_def.fields }
+        lines = []
+        lines << "resource \"aws_dynamodb_table\" \"#{Belt::Inflector.pluralize(model[:name])}\" {"
+        lines << "  name         = \"#{name}\""
+        lines << '  billing_mode = "PAY_PER_REQUEST"'
+        lines << '  hash_key     = "id"'
+        lines << ''
+        lines << '  attribute {'
+        lines << '    name = "id"'
+        lines << '    type = "S"'
+        lines << '  }'
+        lines << ''
+        lines << '  attribute {'
+        lines << '    name = "_recent_pk"'
+        lines << '    type = "S"'
+        lines << '  }'
+        lines << ''
+        lines << '  attribute {'
+        lines << '    name = "createdAt"'
+        lines << '    type = "S"'
+        lines << '  }'
+
+        extra_attrs.each do |attr|
+          lines << ''
+          lines << '  attribute {'
+          lines << "    name = \"#{attr}\""
+          lines << '    type = "S"'
+          lines << '  }'
         end
-      end
-
-      class ModelParser
-        attr_reader :fields
 
-        def initialize
-          @fields = []
+        lines << ''
+        lines << '  global_secondary_index {'
+        lines << '    name            = "RecentIndex"'
+        lines << '    hash_key        = "_recent_pk"'
+        lines << '    range_key       = "createdAt"'
+        lines << '    projection_type = "ALL"'
+        lines << '  }'
+
+        custom_indexes.each do |idx|
+          lines << ''
+          lines << '  global_secondary_index {'
+          lines << "    name            = \"#{idx[:name]}\""
+          lines << "    hash_key        = \"#{idx[:partition_key]}\""
+          lines << "    range_key       = \"#{idx[:sort_key]}\"" if idx[:sort_key]
+          lines << '    projection_type = "ALL"'
+          lines << '  }'
         end
 
-        def field(name, **opts)
-          @fields << { name: name.to_s, type: opts[:type]&.to_s || 'string' }
-        end
+        lines << ''
+        lines << '  point_in_time_recovery {'
+        lines << '    enabled = var.enable_pitr'
+        lines << '  }'
+        lines << ''
+        lines << '  deletion_protection_enabled = var.deletion_protection'
+        lines << ''
+        lines << '  tags = {'
+        lines << "    Name        = \"#{name}\""
+        lines << '    Environment = var.environment'
+        lines << '    ManagedBy   = "Terraform"'
+        lines << '  }'
+        lines << '}'
+
+        lines.join("\n")
+      end
+
+      def table_name(model_name)
+        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
       end
     end
   end

data/lib/belt/cli.rb

@@ -14,6 +14,8 @@ require_relative 'cli/views_command'
 require_relative 'cli/setup_command'
 require_relative 'cli/terraform_command'
 require_relative 'cli/deploy_command'
+require_relative 'cli/backup_config'
+require_relative 'cli/backup_runner'
 require_relative 'cli/server_command'
 require_relative 'cli/routes_command'
 require_relative 'cli/lambda_config_command'

data/lib/belt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.2.4'
+  VERSION = '0.2.6'
 end

data/lib/templates/environment/main.tf.erb

@@ -39,6 +39,8 @@ module "app" {
   environment  = var.environment
   aws_region   = var.aws_region
   domain       = var.domain
+  enable_pitr  = var.enable_pitr
+  deletion_protection = var.deletion_protection
   frontend_urls = concat(
     var.domain != "" ? ["https://${var.environment == "prod" ? var.domain : "${var.environment}.${var.domain}"}"] : [],
     var.environment == "prod" ? [] : ["http://localhost:3000"]

data/lib/templates/environment/terraform.tfvars.erb

@@ -4,3 +4,10 @@ domain      = "<%= @domain %>"
 <% else -%>
 # domain      = "myapp.com"
 <% end -%>
+
+# DynamoDB protection (PITR is true by default everywhere)
+<% if @env_name == 'prod' || @env_name == 'production' -%>
+deletion_protection = true
+<% else -%>
+# deletion_protection = true  # Enable in production environments
+<% end -%>

data/lib/templates/environment/variables.tf.erb

@@ -20,3 +20,15 @@ variable "domain" {
   type        = string
   default     = ""
 }
+
+variable "enable_pitr" {
+  description = "Enable DynamoDB Point-in-Time Recovery (PITR) for all tables"
+  type        = bool
+  default     = true
+}
+
+variable "deletion_protection" {
+  description = "Enable deletion protection on DynamoDB tables (prevents accidental terraform destroy)"
+  type        = bool
+  default     = false
+}

data/lib/templates/module/variables.tf.erb

@@ -37,3 +37,15 @@ variable "lambda_config" {
   type        = any
   default     = {}
 }
+
+variable "enable_pitr" {
+  description = "Enable DynamoDB Point-in-Time Recovery (PITR) for all tables"
+  type        = bool
+  default     = true
+}
+
+variable "deletion_protection" {
+  description = "Enable deletion protection on DynamoDB tables (prevents accidental terraform destroy)"
+  type        = bool
+  default     = false
+}

data/lib/templates/new_app/config/schema.tf.rb.erb

@@ -1,9 +1,22 @@
-Belt.application.schema.draw do
-  # model :post do
-  #   field :title, type: :string, required: true
-  #   field :slug, type: :string, required: true
-  #   field :content, type: :string
-  #   field :status, type: :string, enum: %w[draft published]
-  #   field :published_at, type: :string
-  # end
+Belt.application.schema.define do
+  # API Schema Definitions — request/response contracts
+  #
+  # request :create_thing — declares what an endpoint accepts
+  # model :thing          — declares what an endpoint returns
+  #
+  # Example:
+  #   request :create_post do
+  #     string :title, required: true
+  #     string :body, required: true
+  #     string :status
+  #   end
+  #
+  #   model :post do
+  #     string :id
+  #     string :title
+  #     string :body
+  #     string :status
+  #     string :created_at
+  #     string :updated_at
+  #   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Stowzilla
@@ -70,6 +70,8 @@ files:
 - lib/belt/assets/welcome.css
 - lib/belt/cli.rb
 - lib/belt/cli/app_detection.rb
+- lib/belt/cli/backup_config.rb
+- lib/belt/cli/backup_runner.rb
 - lib/belt/cli/bucket_security.rb
 - lib/belt/cli/console_command.rb
 - lib/belt/cli/deploy_command.rb