mk_framework 0.2.0 → 0.2.1

data/lib/mk_framework/generator/cli.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'optparse'
+
+module MK
+  module Generator
+    class CLI
+      class Cancelled < StandardError; end
+
+      def self.run(argv = ARGV, input: $stdin, output: $stdout)
+        new(input: input, output: output).run(argv)
+      end
+
+      def initialize(input:, output:)
+        @input, @output = input, output
+      end
+
+      def run(argv)
+        arguments = argv.dup
+        inline = nil
+        help = false
+        parser = OptionParser.new do |options|
+          options.banner = 'Usage: mk_frame_init [DESTINATION] [--cli SPEC]'
+          options.on('--cli SPEC', 'Generate without prompts: app_name:blog, model_name:posts, fields:[title:string]') { |value| inline = value }
+          options.on('-h', '--help', 'Show usage') { help = true }
+        end
+        parser.parse!(arguments)
+        if help
+          @output.puts parser
+          @output.puts 'Types: ' + Configuration::TYPES.keys.join(', ')
+          return 0
+        end
+        raise InvalidInput, parser.banner if arguments.length > 1
+        if inline
+          config = Options.parse(inline)
+          return generate(config, arguments.first || config.app_name)
+        end
+
+        @output.puts 'MK app generator — one resource, model, create controller, and handler.'
+        @output.puts 'Press Ctrl-C to cancel. All fields are required; id and timestamps are automatic.'
+        app = validated('1. App name (snake_case)') { |value| Configuration.app_name!(value) }
+        model = validated('2. Model name (singular snake_case)') { |value| Configuration.model_name!(value) }
+        resource = validated('3. Resource/table name (plural snake_case)', default: Naming.plural(model)) do |value|
+          Configuration.identifier!(value, label: 'Resource name')
+        end
+        fields = collect_fields
+        config = Configuration.new(app_name: app, model_name: model, resource: resource, fields: fields)
+        destination = File.expand_path(arguments.first || app)
+        @output.puts "\nApp: #{config.namespace}; model: #{config.model_class}; route: POST /#{resource}"
+        @output.puts "Fields: #{fields.map { |field| "#{field[:name]}:#{field[:type]}" }.join(', ')}"
+        @output.puts "Directory: #{destination}"
+        answer = validated('5. Generate these files? (y/n)', default: 'y') do |value|
+          raise InvalidInput, 'Enter y or n.' unless %w[y n yes no].include?(value.downcase)
+          value.downcase
+        end
+        raise Cancelled if %w[n no].include?(answer)
+        generate(config, destination)
+      rescue Cancelled, Interrupt
+        @output.puts "\nCancelled."
+        1
+      rescue InvalidInput, OptionParser::ParseError, SystemCallError => error
+        @output.puts "Error: #{error.message}"
+        1
+      end
+
+      private
+
+      def generate(config, destination)
+        destination = Project.new(config).generate(destination)
+        @output.puts "\nCreated #{destination}\nNext steps:"
+        @output.puts "  cd #{Shellwords.escape(destination)}"
+        @output.puts "  bundle install\n  bundle exec rake db:migrate\n  bundle exec rake routes\n  bundle exec rspec"
+        0
+      end
+
+      def ask(prompt, default: nil)
+        @output.print "#{prompt}#{default ? " [#{default}]" : ''}: "
+        @output.flush
+        line = @input.gets
+        raise Cancelled unless line
+        value = line.strip
+        value.empty? && default ? default : value
+      end
+
+      def validated(prompt, default: nil)
+        loop do
+          value = ask(prompt, default: default)
+          begin
+            return yield(value)
+          rescue InvalidInput => error
+            @output.puts error.message
+          end
+        end
+      end
+
+      def collect_fields
+        fields = []
+        @output.puts '4. Add fields. Leave the next field name blank when finished.'
+        loop do
+          name = validated('Field name') do |value|
+            if value.empty?
+              raise InvalidInput, 'Add at least one field.' if fields.empty?
+            else
+              Configuration.field!(value, 'string')
+              raise InvalidInput, 'That field already exists.' if fields.any? { |field| field[:name] == value }
+            end
+            value
+          end
+          break if name.empty?
+          types = Configuration::TYPES.keys
+          @output.puts types.each_with_index.map { |type, index| "  #{index + 1}. #{type}" }.join("\n")
+          type = validated('Type (number or name)', default: 'string') do |value|
+            selected = value.match?(/\A[1-9][0-9]*\z/) ? types[value.to_i - 1] : value
+            raise InvalidInput, 'Choose a listed type.' unless types.include?(selected)
+            selected
+          end
+          fields << {name: name, type: type}
+        end
+        fields
+      end
+    end
+  end
+end

data/lib/mk_framework/generator/configuration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module MK
+  module Generator
+    class InvalidInput < ArgumentError; end
+
+    class Configuration
+      TYPES = {
+        'string' => ['String', 'String', 'Example'],
+        'text' => ['String', 'String', 'Example text'],
+        'integer' => ['Integer', 'Integer', 1],
+        'float' => ['Float', '[Integer, Float]', 1.5],
+        'boolean' => ['TrueClass', ':boolean', false],
+        'date' => ['Date', 'String', '2026-01-01'],
+        'datetime' => ['DateTime', 'String', '2026-01-01T12:00:00Z']
+      }.transform_values(&:freeze).freeze
+      KEYWORDS = %w[alias and begin break case class def defined do else elsif end ensure false
+                    for if in module next nil not or redo rescue retry return self super then
+                    true undef unless until when while yield __FILE__ __LINE__ __ENCODING__].freeze
+      RESERVED_FIELDS = (KEYWORDS + %w[id created_at updated_at save save_changes destroy delete
+        values errors valid validate set update refresh new db dataset model table_name columns
+        pk pk_hash this associations changed_columns raise fail send public_send method methods
+        object_id instance_eval instance_exec initialize hash eql equal freeze frozen inspect
+        to_s to_json to_hash to_a tap then itself dup clone before_validation after_validation
+        before_save after_save before_create after_create before_update after_update
+        before_destroy after_destroy around_validation around_save around_create around_update
+        around_destroy set_fields update_fields validate_save skip_validation_on_next_save
+        get_column_value set_column_value raise_on_save_failure use_transactions require_modification]).freeze
+      RESERVED_MODELS = %w[app controller handler database tasks root db].freeze
+      RESERVED_CONSTANTS = %w[Object BasicObject Class Module Kernel String Integer Float Numeric
+        TrueClass FalseClass NilClass Array Hash Symbol Date DateTime Time File Dir Io Process
+        Thread Exception StandardError Sequel Roda Rack Rspec Rake Json Logger Erb FileUtils].freeze
+
+      attr_reader :app_name, :model_name, :resource, :fields
+
+      def self.identifier!(value, label: 'Name')
+        unless value.is_a?(String) && value.match?(/\A[a-z][a-z0-9]*(?:_[a-z0-9]+)*\z/) && !KEYWORDS.include?(value)
+          raise InvalidInput, "#{label} must be a lowercase Ruby name, such as blog or blog_post."
+        end
+        value
+      end
+
+      def self.model_name!(value)
+        identifier!(value, label: 'Model name')
+        if RESERVED_MODELS.include?(value) || RESERVED_CONSTANTS.include?(camelize(value))
+          raise InvalidInput, 'That model name is reserved by Ruby or the application.'
+        end
+        value
+      end
+
+      def self.app_name!(value)
+        identifier!(value, label: 'App name')
+        raise InvalidInput, 'That app name conflicts with a Ruby or library constant.' if RESERVED_CONSTANTS.include?(camelize(value))
+        value
+      end
+
+      def self.field!(name, type)
+        identifier!(name, label: 'Field name')
+        raise InvalidInput, "Field #{name} is reserved; id and timestamps are generated automatically." if RESERVED_FIELDS.include?(name)
+        raise InvalidInput, "Unknown field type: #{type}." unless TYPES.key?(type)
+        {name: name.dup.freeze, type: type.dup.freeze}.freeze
+      end
+
+      def self.camelize(name) = name.split('_').map(&:capitalize).join
+
+      def initialize(app_name:, model_name:, resource:, fields:)
+        @app_name = self.class.app_name!(app_name).dup.freeze
+        @model_name = self.class.model_name!(model_name).dup.freeze
+        @resource = self.class.identifier!(resource, label: 'Resource name').dup.freeze
+        if self.class.camelize(resource) + 'CreateController' == model_class ||
+           self.class.camelize(resource) + 'CreateHandler' == model_class
+          raise InvalidInput, 'Model name conflicts with a generated action class.'
+        end
+        raise InvalidInput, 'Add at least one field.' if fields.empty?
+        @fields = fields.map { |field| self.class.field!(field.fetch(:name), field.fetch(:type)) }.freeze
+        raise InvalidInput, 'Field names must be unique.' unless @fields.map { |f| f[:name] }.uniq.length == @fields.length
+        freeze
+      end
+
+      def namespace = self.class.camelize(app_name)
+      def model_class = self.class.camelize(model_name)
+      def action_prefix = self.class.camelize(resource)
+      def field_names = fields.map { |field| field[:name] }
+      def example = fields.to_h { |field| [field[:name], TYPES.fetch(field[:type])[2]] }
+    end
+  end
+end

data/lib/mk_framework/generator/options.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module MK
+  module Generator
+    module Naming
+      IRREGULAR = {'person' => 'people', 'child' => 'children', 'man' => 'men', 'woman' => 'women'}.freeze
+
+      def self.singular(name)
+        return IRREGULAR.key(name) if IRREGULAR.value?(name)
+        return "#{name[0...-3]}y" if name.end_with?('ies')
+        return name[0...-2] if name.match?(/(?:sses|shes|ches|xes|zes|statuses)\z/)
+        name.end_with?('s') && !name.end_with?('ss', 'us') ? name[0...-1] : name
+      end
+
+      def self.plural(name)
+        return IRREGULAR.fetch(name) if IRREGULAR.key?(name)
+        return "#{name[0...-1]}ies" if name.match?(/[^aeiou]y\z/)
+        name.match?(/(?:s|sh|ch|x|z)\z/) ? "#{name}es" : "#{name}s"
+      end
+    end
+
+    # This is a small data grammar, never Ruby evaluation or shell input.
+    class Options
+      def self.parse(source)
+        new(source).parse
+      end
+
+      def initialize(source)
+        @scanner = StringScanner.new(source)
+      end
+
+      def parse
+        options = {}
+        loop do
+          key = identifier
+          raise InvalidInput, "Unknown option: #{key}." unless %w[app_name model_name resource_name fields].include?(key)
+          raise InvalidInput, "Duplicate option: #{key}." if options.key?(key)
+          token(':')
+          options[key] = key == 'fields' ? fields : identifier
+          whitespace
+          break if @scanner.eos?
+          token(',')
+        end
+        %w[app_name model_name fields].each do |key|
+          raise InvalidInput, "Missing option: #{key}." unless options.key?(key)
+        end
+        model = Naming.singular(options.fetch('model_name'))
+        Configuration.new(app_name: options.fetch('app_name'), model_name: model,
+          resource: options.fetch('resource_name') { Naming.plural(model) }, fields: options.fetch('fields'))
+      end
+
+      private
+
+      def fields
+        token('[')
+        result = []
+        whitespace
+        unless @scanner.peek(1) == ']'
+          loop do
+            name = identifier
+            token(':')
+            result << {name: name, type: identifier}
+            whitespace
+            break if @scanner.peek(1) == ']'
+            token(',')
+          end
+        end
+        token(']')
+        result
+      end
+
+      def whitespace = @scanner.skip(/\s*/)
+
+      def identifier
+        whitespace
+        @scanner.scan(/[a-z][a-z0-9_]*/) || invalid!
+      end
+
+      def token(value)
+        whitespace
+        invalid! unless @scanner.scan(/#{Regexp.escape(value)}/)
+      end
+
+      def invalid!
+        raise InvalidInput, 'Invalid --cli syntax. Use app_name:blog, model_name:posts, fields:[title:string, contents:text].'
+      end
+    end
+  end
+end

data/lib/mk_framework/generator/project.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+require 'json'
+require_relative '../version'
+
+module MK
+  module Generator
+    class Project
+      TEMPLATES = {
+        'Gemfile' => 'Gemfile', 'Rakefile' => 'Rakefile', 'gitignore' => '.gitignore',
+        'README.md' => 'README.md', 'app.rb' => 'app.rb', 'config.ru' => 'config.ru',
+        'database.rb' => 'database.rb', 'migration.rb' => 'db/migrations/001_initial.rb',
+        'model.rb' => 'models/%{model}.rb',
+        'controller.rb' => 'routes/%{resource}/controllers/create.rb',
+        'handler.rb' => 'routes/%{resource}/handlers/create.rb',
+        'spec_helper.rb' => 'spec/spec_helper.rb', 'request_spec.rb' => 'spec/request/%{resource}_spec.rb'
+      }.freeze
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def generate(destination)
+        destination = File.expand_path(destination)
+        raise InvalidInput, 'Destination already exists; choose a new directory.' if File.exist?(destination) || File.symlink?(destination)
+        parent = File.dirname(destination)
+        raise InvalidInput, 'Destination parent directory does not exist.' unless File.directory?(parent)
+
+        # Render before touching the destination, then reserve it without overwriting anything.
+        files = render
+        Dir.mkdir(destination)
+        files.each do |relative, content|
+          target = File.join(destination, relative)
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, content, mode: 'wx')
+        end
+        destination
+      rescue Errno::EEXIST
+        raise InvalidInput, 'Destination already exists; choose a new directory.'
+      end
+
+      def render
+        config = @configuration
+        TEMPLATES.to_h do |template, path|
+          source = File.read(File.join(__dir__, 'templates', "#{template}.erb"))
+          [format(path, model: config.model_name, resource: config.resource), ERB.new(source, trim_mode: '-').result(binding)]
+        end
+      end
+    end
+  end
+end

data/lib/mk_framework/generator/tasks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rake'
+require_relative '../generator'
+
+namespace :mk_framework do
+  desc 'Generate an app (optional DESTINATION=/path/to/app and APP_SPEC for non-interactive input)'
+  task :init do
+    arguments = ENV['DESTINATION'] ? [ENV.fetch('DESTINATION')] : []
+    arguments += ['--cli', ENV.fetch('APP_SPEC')] if ENV['APP_SPEC']
+    abort 'App generation did not complete.' unless MK::Generator::CLI.run(arguments).zero?
+  end
+end

data/lib/mk_framework/generator/templates/Gemfile.erb

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gem 'mk_framework', '~> <%= MK::VERSION %>'
+gem 'sequel', '>= 5.92', '< 6'
+gem 'sqlite3', '~> 2.9'
+gem 'rake', '~> 13.4'
+gem 'rackup', '~> 2.3'
+gem 'puma', '~> 8.0'
+
+group :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rack-test', '~> 2.2'
+end

data/lib/mk_framework/generator/templates/README.md.erb

@@ -0,0 +1,54 @@
+# <%= config.namespace %>
+
+A self-contained MK app with one `<%= config.model_class %>` model and one resource
+route: `POST /<%= config.resource %>`. The create controller prepares the record;
+MK saves it once, and the handler returns JSON with status 201.
+
+## Setup
+
+```sh
+bundle install
+bundle exec rake db:migrate
+bundle exec rake routes
+bundle exec rspec
+```
+
+Migrations run explicitly, before boot. Development data defaults to
+`<%= config.app_name %>.db` beside `database.rb`. `DATABASE_URL`, `DB_POOL_SIZE`, and
+`DB_POOL_TIMEOUT` configure other connections. Tests always use private in-memory
+SQLite databases and ignore `DATABASE_URL`.
+
+To serve the app locally:
+
+```sh
+bundle exec rackup --host 127.0.0.1 --port 9292
+```
+
+Then create a record:
+
+```sh
+curl -i http://127.0.0.1:9292/<%= config.resource %> \
+  -H 'Content-Type: application/json' \
+  -d '<%= JSON.generate(config.example) %>'
+```
+
+All chosen fields are required. Invalid input types return 400; missing fields or
+blank text return 422. Date and datetime inputs use ISO 8601 strings. Booleans
+accept JSON `true` and `false`; numeric fields accept JSON numbers. Unknown fields
+are ignored. IDs and timestamps are assigned by the app.
+
+## Files and next changes
+
+- `database.rb` connects; `db/migrations/001_initial.rb` defines the table.
+- `models/<%= config.model_name %>.rb` owns validations and the public field list.
+- `app.rb` loads dependencies and models, configures routes, and calls `boot!`.
+- `config.ru` exposes `<%= config.namespace %>::App.app` to Rack.
+- `routes/<%= config.resource %>/controllers/create.rb` permits inputs and returns an unsaved model.
+- `routes/<%= config.resource %>/handlers/create.rb` filters raw data and formats the response.
+- `spec/request/<%= config.resource %>_spec.rb` checks persistence and error responses.
+
+Add a field through a new migration, update permitted input and model validation,
+then decide whether to expose it in `public_attributes_list`. Add another action by
+creating its controller/handler pair and adding it to `resources` in `app.rb`.
+The starter has no authentication: implement access rules in controllers before
+using it for private data. Handlers must not query or persist records.

data/lib/mk_framework/generator/templates/Rakefile.erb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rbconfig'
+
+namespace :db do
+  desc 'Apply database migrations explicitly'
+  task :migrate do
+    require_relative 'database'
+    Sequel::Migrator.run(<%= config.namespace %>::DB, File.join(__dir__, 'db/migrations'))
+  end
+end
+
+desc 'Print the compiled resource routes'
+task :routes do
+  require_relative 'app'
+  puts <%= config.namespace %>::App.route_table
+end
+
+desc 'Run isolated request specs'
+task :spec do
+  sh RbConfig.ruby, '-S', 'rspec', File.join(__dir__, 'spec')
+end
+
+task default: :spec

data/lib/mk_framework/generator/templates/app.rb.erb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'mk_framework/sequel'
+require_relative 'database'
+require_relative 'models/<%= config.model_name %>'
+
+module <%= config.namespace %>
+  class App < MK::Application
+    configure root: ROOT, namespace: ::<%= config.namespace %>, legacy_post_routes: false
+
+    resource_routes do
+      resources :<%= config.resource %>, only: [:create], singular: '<%= config.model_name %>'
+    end
+  end
+
+  App.boot!
+end

data/lib/mk_framework/generator/templates/config.ru.erb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'app'
+run <%= config.namespace %>::App.app

data/lib/mk_framework/generator/templates/controller.rb.erb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+<% if config.fields.any? { |field| %w[date datetime].include?(field[:type]) } -%>
+
+require 'date'
+<% end -%>
+
+module <%= config.namespace %>
+  class <%= config.action_prefix %>CreateController < MK::Controller
+    route do |r|
+      attributes = r.input.permit(
+<% config.fields.each_with_index do |field, index| -%>
+        <%= field[:name] %>: <%= MK::Generator::Configuration::TYPES.fetch(field[:type])[1] %><%= index < config.fields.length - 1 ? ',' : '' %>
+<% end -%>
+      )
+<% config.fields.select { |field| %w[date datetime].include?(field[:type]) }.each do |field| -%>
+      if attributes.key?(:<%= field[:name] %>)
+        begin
+          attributes[:<%= field[:name] %>] = <%= field[:type] == 'date' ? 'Date' : 'DateTime' %>.iso8601(attributes.fetch(:<%= field[:name] %>))
+        rescue ArgumentError
+          raise MK::BadRequest, 'Invalid parameter: <%= field[:name] %> (expected ISO 8601)'
+        end
+      end
+<% end -%>
+      <%= config.model_class %>.new(attributes)
+    end
+  end
+end

data/lib/mk_framework/generator/templates/database.rb.erb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'sequel/extensions/migration'
+
+module <%= config.namespace %>
+  ROOT = __dir__.freeze
+  DB = if ENV['RACK_ENV'] == 'test'
+         Sequel.sqlite(max_connections: 1)
+       else
+         url = ENV.fetch('DATABASE_URL') { "sqlite://#{File.join(ROOT, '<%= config.app_name %>.db')}" }
+         Sequel.connect(url, max_connections: Integer(ENV.fetch('DB_POOL_SIZE', '5')),
+                        pool_timeout: Integer(ENV.fetch('DB_POOL_TIMEOUT', '5')))
+       end
+end

data/lib/mk_framework/generator/templates/gitignore.erb

@@ -0,0 +1,10 @@
+.bundle/
+vendor/
+.env
+.env.*
+*.db
+*.db-*
+*.sqlite*
+log/
+tmp/
+.DS_Store

data/lib/mk_framework/generator/templates/handler.rb.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= config.namespace %>
+  class <%= config.action_prefix %>CreateHandler < MK::Handler
+    handler do |r|
+      r.response.status = 201
+      {<%= config.model_name %>: model.slice(*<%= config.model_class %>.public_attributes_list)}
+    end
+  end
+end

data/lib/mk_framework/generator/templates/migration.rb.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table :<%= config.resource %> do
+      primary_key :id
+<% config.fields.each do |field| -%>
+      <%= MK::Generator::Configuration::TYPES.fetch(field[:type])[0] %> :<%= field[:name] %>, null: false<%= field[:type] == 'text' ? ', text: true' : '' %>
+<% end -%>
+      DateTime :created_at, null: false
+      DateTime :updated_at, null: false
+    end
+  end
+end

data/lib/mk_framework/generator/templates/model.rb.erb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module <%= config.namespace %>
+  class <%= config.model_class %> < Sequel::Model(DB[:<%= config.resource %>])
+    plugin :validation_helpers
+    plugin :timestamps, update_on_create: true
+
+    def validate
+      super
+      validates_not_null %i[<%= config.field_names.join(' ') %>]
+<% text_fields = config.fields.select { |field| %w[string text].include?(field[:type]) }.map { |field| field[:name] } -%>
+<% unless text_fields.empty? -%>
+      validates_presence %i[<%= text_fields.join(' ') %>]
+<% end -%>
+    end
+
+    def self.public_attributes_list
+      %i[id <%= config.field_names.join(' ') %> created_at updated_at]
+    end
+  end
+end

data/lib/mk_framework/generator/templates/request_spec.rb.erb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+
+RSpec.describe '<%= config.model_class %> creation' do
+  let(:client) { Rack::MockRequest.new(Rack::Builder.parse_file(File.join(<%= config.namespace %>::ROOT, 'config.ru'))) }
+  let(:attributes) { JSON.parse(<%= JSON.generate(config.example).inspect %>) }
+
+  before { <%= config.namespace %>::<%= config.model_class %>.dataset.delete }
+
+  it 'persists permitted fields and returns a 201 response through the Rack entrypoint' do
+    response = client.post('/<%= config.resource %>', input: JSON.generate(attributes.merge('id' => 999)),
+      'CONTENT_TYPE' => 'application/json')
+
+    expect(response.status).to eq(201)
+    record = <%= config.namespace %>::<%= config.model_class %>.first
+    expect(record).not_to be_nil
+    expect(record.id).not_to eq(999)
+    payload = JSON.parse(response.body).fetch('<%= config.model_name %>')
+    expect(payload.fetch('id')).to eq(record.id)
+    expect(payload.keys).to match_array(%w[id <%= config.field_names.join(' ') %> created_at updated_at])
+  end
+
+  it 'rejects missing required fields without inserting a record' do
+    response = client.post('/<%= config.resource %>', input: '{}', 'CONTENT_TYPE' => 'application/json')
+
+    expect(response.status).to eq(422)
+    expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(0)
+  end
+
+  it 'rejects an invalid field type without inserting a record' do
+    attributes['<%= config.fields.first[:name] %>'] = []
+    response = client.post('/<%= config.resource %>', input: JSON.generate(attributes), 'CONTENT_TYPE' => 'application/json')
+
+    expect(response.status).to eq(400)
+    expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(0)
+  end
+end

data/lib/mk_framework/generator/templates/spec_helper.rb.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+ENV['RACK_ENV'] = 'test'
+require 'rspec'
+require 'rack/mock'
+require 'rack/builder'
+require 'json'
+require_relative '../database'
+Sequel::Migrator.run(<%= config.namespace %>::DB, File.join(<%= config.namespace %>::ROOT, 'db/migrations'))
+require_relative '../app'
+
+RSpec.configure do |config|
+  config.after(:suite) { <%= config.namespace %>::DB.disconnect }
+end

data/lib/mk_framework/generator.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'generator/configuration'
+require_relative 'generator/options'
+require_relative 'generator/project'
+require_relative 'generator/cli'

data/lib/mk_framework/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MK
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end