mk_framework 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68f913eebaf1aa8a9b4d423b528e4720a6508b5f0f130c03b15d039458ec6d1
-  data.tar.gz: be858c42ce6d158eb5e658bb9a7e20ec9a775795f0f5956b03100ee733dd4c2f
+  metadata.gz: 28e516ad56933bcfe68ce986d9bc872148ef289ef9fabfe90f9315786fae471e
+  data.tar.gz: ab4fda8fc53f07a5fd2df9921c40fc95182caf6be21542207d06c7716f0e255d
 SHA512:
-  metadata.gz: 79a22c1dcd019cfcb8ad3653a9fdd84c4246de7cdc95faa21132be72dc1306285c49bc5a37f29a3bdd64342718024ac126fcf33e7fe38dcdbde673dca3e73536
-  data.tar.gz: f42544ff916968bf3cfc5152b9ed3cd866050b301407e5f1b840637db4b73226f1a3a604b36102b0195b8a9e584c4e7ab90cb590afee744bf9462b1b0ac79538
+  metadata.gz: 2eeebeca751cec2bc9f5a372d4a927d72fcfc28fb86e859c56f0557e905067f3c4dabf6dc57ff28ea118d7d5813c696857a89c75ac7abe4441581a0f6c8efc03
+  data.tar.gz: 14dc30546bdbecd0e3eb3bf6e386565c7fc09813353c7b79d2792185c8a15689518221c7e7e4f136f893834a51f4691a90cc0e802f04e28286c440fbdc7e5939

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.5 — 2026-09-12
+
+- Generate Gemfile dependencies in alphabetical order within each group.
+- Align generated database connection keyword arguments for RuboCop.
+- Generate bracketed symbol arrays in model validations and public attribute lists.
+
 ## 0.2.3 — 2026-09-12
 
 - Use `rack-test` and `Rack::Test::Methods` in generated request specs.

data/README.md

@@ -123,7 +123,7 @@ blog_api/
 explicit and run before models load. Tests always migrate a private in-memory
 database. The controller permits the chosen fields and returns `Post.new(...)`;
 MK saves once, then the handler returns `{post: ...}` with status 201. Index returns
-`{posts: [...]}`; show, update, and delete return `{post: ...}` with status 200.
+`{posts: [...]}` with bounded `limit`/`offset` pagination; show, update, and delete return `{post: ...}` with status 200.
 PATCH and PUT preserve omitted fields; missing records return 404. The generated
 README includes a local server command, an example request, and extension guidance.
 
@@ -140,10 +140,10 @@ task in another project's Rakefile, add `require 'mk_framework/generator/tasks'`
 
 ## Try the examples
 
-The seven sample applications live in
+Twenty paired sample applications (JSON APIs and MkFrame frontends) live in
 [mk_framework_sample_apps](https://github.com/makevoid/mk_framework_sample_apps)
-and install MK from RubyGems. Both GitHub repositories are private; installing the
-published gem does not require access to the framework repository.
+and install MK from RubyGems. Each sample has its own README, database migrations
+and isolated request specs. Backend use does not require a framework source checkout.
 
 From a sample-app checkout:
 
@@ -166,9 +166,22 @@ stub HTTP and require no personal API key or internet connection.
 | [2](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app2/README.md) | Todo validation and request specs |
 | [3](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app3/README.md) | Custom response envelopes |
 | [4](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app4/README.md) | Blog posts, nested comments, parent scoping |
-| [5](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app5/README.md) | Kanban cards, status validation, nested comments |
+| [5](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app5/README.md) | Kanban cards, validation, nested comments |
 | [6](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app6/README.md) | Weather client, deadlines, atomic cache refresh |
-| [7](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app7/README.md) | Three-column Kanban board, ordering, priorities, filters, archive and comments |
+| [7](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app7/README.md) | Kanban board, ordering, priorities, filters, archive and comments |
+| [8](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app8/README.md) | Single-user ecommerce, product image uploads and a persistent cart |
+| [9](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app9/README.md) | Fictional electric car inventory, charging specs and reservations |
+| [10](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app10/README.md) | Buildlog developer journal, project portfolio and private publishing workbench |
+| [11](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app11/README.md) | Rolecraft job board, employer submissions, moderation and private applications |
+| [12](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app12/README.md) | Reboot Market electronics classifieds, photo uploads, private inquiries, saved searches and moderation |
+| [13](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app13/README.md) | Pinpoint map directory, geographic filters, contributor history and transactional approval |
+| [14](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app14/README.md) | Studio Hours timed resource bookings, Zurich availability, maintenance and transactional conflict prevention |
+| [15](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app15/README.md) | Pantry Table recipes, private meal plans, pantry stock and derived shopping quantities |
+| [16](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app16/README.md) | Assembly community events, workshop capacity, FIFO waitlists, organizer management and check-in |
+| [17](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app17/README.md) | Fairshare private expense groups, exact splits, receipts, balances and reimbursements |
+| [18](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app18/README.md) | Signalboard feedback, voting, moderation, duplicate merges, roadmap and releases |
+| [19](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app19/README.md) | Night Archive NASA discovery, private collections and observing journal |
+| [20](https://github.com/makevoid/mk_framework_sample_apps/blob/main/sample_app20/README.md) | Fieldwork private plant collection, care schedules and growth journals |
 
 ## Walkthrough: sample app 4, a blog API
 
@@ -186,16 +199,14 @@ parent scoping checks the relationship, while user access rules belong in your a
 
 ### Directory structure
 
-Each sample carries its own namespaced database and Rake helpers in `support/`,
-so you can copy `sample_app4/` alone to start a separate project. This tree lists
+The samples share database and Rake helpers in the repository-level `support/`
+directory. Keep that directory when copying a sample; use the CLI above for a
+self-contained starter. This tree lists
 the six action files explained below; the sample also includes the remaining CRUD
 controllers and handlers for both resources.
 
 ```text
 sample_app4/
-├── support/
-│   ├── database.rb              # SampleApp4::Database: connections and migrations
-│   └── tasks.rb                 # SampleApp4::Tasks: db:migrate, routes, and specs
 ├── Gemfile
 ├── Rakefile
 ├── database.rb              # SampleApp4::ROOT and SampleApp4::DB
@@ -235,7 +246,7 @@ and request-test dependencies:
 ```ruby
 source 'https://rubygems.org'
 
-gem 'mk_framework', '~> 0.2.0'
+gem 'mk_framework', '~> 0.2.2'
 gem 'sequel', '>= 5.92', '< 6'
 gem 'sqlite3', '~> 2.9'
 gem 'rake', '~> 13.4'
@@ -257,8 +268,8 @@ bundle exec rake routes
 bundle exec rspec
 ```
 
-`Rakefile` loads `support/tasks.rb` and installs the local tasks with
-`SampleApp4::Tasks.install(__dir__)`.
+`Rakefile` loads `../support/tasks.rb` and installs the shared tasks with
+`SampleTasks.install(__dir__)`.
 `db:migrate` loads `database.rb` and applies `db/migrations/001_initial.rb` before
 any models are loaded. The migration creates `posts` and `comments`, including
 required timestamps and a non-null `comments.post_id` foreign key with cascading
@@ -269,15 +280,15 @@ deletion. Schema changes are an explicit step; starting the app never migrates i
 ```ruby
 # frozen_string_literal: true
 
-require_relative 'support/database'
+require_relative '../support/database'
 
 module SampleApp4
   ROOT = __dir__.freeze
-  DB = Database.connect(root: ROOT, filename: 'blog.db')
+  DB = SampleDatabase.connect(root: ROOT, filename: 'blog.db')
 end
 ```
 
-`SampleApp4::Database.connect` defaults to `sample_app4/blog.db`, using an absolute path.
+`SampleDatabase.connect` defaults to `sample_app4/blog.db`, using an absolute path.
 It accepts `DATABASE_URL`, `DB_POOL_SIZE`, and `DB_POOL_TIMEOUT` for deployment.
 In tests it always opens a private in-memory SQLite database; `spec_helper.rb`
 migrates that database before requiring `app.rb`.
@@ -599,25 +610,196 @@ Known paths with unsupported methods return 405 and `Allow`; unknown paths retur
 Read [nested routes and authorization](docs/routing.md) for scopes, namespaces,
 shallow routes, custom actions, explicit class mappings, and parent ownership.
 
-## Inputs, responses, and errors
-
-- `r.path_params` is a frozen symbol-keyed hash containing only URL captures.
-- `r.input` validates body/query input independently of path IDs. `require(:name)`
-  requires a typed field; `permit(name: String)` allows only declared fields.
-- `:boolean` accepts booleans and the form strings `true`, `false`, `1`, `0`.
-  Nullable fields must explicitly include `NilClass` in their accepted types.
-- `r.params` remains compatible with older controllers, with path IDs taking
-  precedence. Never use client input to establish a parent relationship.
-- `r.page` validates `limit` (default 25, maximum 100) and `offset` (maximum 10,000).
-  `paginate(dataset, r)` in `MK::Persistence` uses an ordered, bounded query.
-  Implement cursor pagination in your application when large offsets are needed.
-- JSON request bodies must be objects. Malformed JSON and malformed query inputs
-  produce 400. Bodies above 1 MiB produce 413, including bodies without a length.
-- `MK::BadRequest`, `Unauthorized`, `Forbidden`, `NotFound`, `Conflict`,
-  `ValidationError`, and `BadGateway` represent intentional public errors.
-  Their messages are public: never place secrets in them.
-- Unexpected errors return JSON with `error: "Server error"` and a request ID.
-  The same ID appears in `X-Request-ID` and the structured error log.
+## Working with the request (`r`)
+
+`r` is the current Roda request, extended with MK's input and pagination helpers.
+Controllers use `route do |r|` to load records and prepare changes; handlers use
+`handler do |r|` to format the resulting raw data and choose a response status.
+The snippets below belong inside the application's namespace, after defining its
+models. Define routes and configuration before calling `App.boot!`.
+
+### Declare routes
+
+Inside your `MK::Application` subclass:
+
+```ruby
+configure root: ROOT, namespace: Blog, legacy_post_routes: false
+
+resource_routes do
+  resources :posts do
+    resources :comments
+  end
+end
+```
+
+`resources :posts` maps the CRUD URLs in the table above to
+`PostsIndexController`/`PostsIndexHandler`, `PostsShowController`/`PostsShowHandler`,
+and the corresponding create, update and delete pairs. Files live under
+`routes/posts/controllers/` and `routes/posts/handlers/`. Nested comments still
+use action files under `routes/comments/`; nesting changes the URL, not the files.
+
+Restrict actions or add a named endpoint explicitly:
+
+```ruby
+resource_routes do
+  resources :posts, only: %i[index show] do
+    member :publish, via: :post
+  end
+end
+```
+
+The member action maps `POST /posts/:id/publish` to
+`PostsPublishController` and `PostsPublishHandler`. Supply both classes before
+boot. Custom actions do not automatically save their returned models; persistence
+must be explicit. Inspect the compiled mapping with `puts App.route_table`.
+
+### URL identifiers: `r.path_params`
+
+For `PUT /posts/12/comments/34`, the nested declaration captures:
+
+```ruby
+r.path_params # => { post_id: '12', id: '34' }
+```
+
+This is a frozen hash with symbol keys and string values. IDs may be slugs or
+UUIDs; MK does not coerce them to integers. Collection routes contain parent IDs
+but no member `:id`. Body and query fields cannot overwrite these captures.
+
+Load a nested record through its parent in the controller:
+
+```ruby
+route do |r|
+  post = Post[r.path_params.fetch(:post_id)] or raise MK::NotFound
+  comment = post.comments_dataset.where(id: r.path_params.fetch(:id)).first
+  raise MK::NotFound unless comment
+
+  comment.set(r.input.permit(content: String))
+end
+```
+
+The URL describes the relationship; it does not load or authorize a parent.
+In an authenticated app, first scope the parent query to the current user's
+allowed records. Assign foreign keys from that parent, not from client input.
+
+### Body and query fields: `r.input`
+
+Use `permit` to select fields and validate their types. It returns a symbol-keyed
+hash, drops unknown fields, and omits fields the client did not send:
+
+```ruby
+route do |r|
+  attributes = r.input.permit(
+    title: String,
+    description: [String, NilClass],
+    published: :boolean
+  )
+  Post.new(attributes)
+end
+```
+
+`permit` does not require a field to be present. Model validation can reject a
+missing title with 422 when MK saves the returned model. A present value of the
+wrong type raises `MK::BadRequest` (400). `NilClass` explicitly permits JSON null;
+`String` alone does not. Length, uniqueness and other domain rules belong in the
+model or controller. Nested objects are not recursively allowlisted for you.
+
+For a required input, call `require` (its default type is `String`):
+
+```ruby
+query = r.input.require(:query)
+quantity = r.input.require(:quantity, type: Integer)
+```
+
+A missing key or invalid type returns 400. An empty string still has type String;
+check whether it is meaningful in your application. `Integer` accepts a JSON
+integer, not the query string `"3"`. Use the integer helper for numeric query
+parameters or form fields:
+
+```ruby
+quantity = r.input.integer(:quantity, default: 1, min: 1, max: 20)
+```
+
+This accepts integers and strings of decimal digits, applies the default only
+when the field is absent, and returns 400 for invalid values or bounds. It does
+not silently clamp them. `:boolean` accepts JSON `true`/`false` and the strings
+`"true"`, `"false"`, `"1"`, `"0"`; false is retained in permitted attributes.
+Dates arrive as strings: parse them explicitly, as the CLI's date fields do.
+
+`r.input` reads body/query input separately from path captures. The compatibility
+`r.params` hash combines input with string-keyed path captures, and path values
+win on collision. Prefer `r.path_params` for identity and `r.input` for attributes.
+
+### Bounded pagination: `r.page`
+
+For `GET /posts?limit=10&offset=20`, `r.page` returns
+`{ limit: 10, offset: 20 }`. Apply it to an ordered query:
+
+```ruby
+route do |r|
+  page = r.page
+  Post.order(:id).limit(page[:limit], page[:offset])
+end
+```
+
+The helper validates parameters; it does not query the database or add response
+metadata. Defaults are `limit: 25` and `offset: 0`. Allowed limits are 1–100 and
+allowed offsets are 0–10,000. Invalid inputs return 400. Override the bounds in
+the application before boot:
+
+```ruby
+configure page_size: 20, max_page_size: 50, max_offset: 5_000
+```
+
+All three settings must be positive integers, and `page_size` cannot exceed
+`max_page_size`. Controllers that include `MK::Persistence` can instead use
+`paginate(Post.dataset, r)`, which orders by `id`, applies these bounds and returns
+an array. For large datasets, implement cursor pagination in your application.
+
+### Response status, headers and early returns
+
+Handlers receive prepared raw data through `model` and return hashes or arrays.
+MK serializes the response; do not call `to_json` in a handler:
+
+```ruby
+handler do |r|
+  r.response.status = 201
+  r.response['location'] = "/posts/#{model.fetch(:id)}"
+  { post: model.slice(:id, :title) }
+end
+```
+
+Use an MK error for an intentional failure such as `raise MK::NotFound` or
+`raise MK::Forbidden`. Use `r.halt` when you need an explicit early response:
+
+```ruby
+r.halt(409, { error: 'Post is already published' })
+```
+
+Request-scoped application data can be stored in `r.env`, for example a verified
+user set by `before_request`. Native Roda routes also work and run before resource
+routes; return `nil` when they should fall through:
+
+```ruby
+route do |r|
+  r.get('health') { { ok: true } }
+  nil
+end
+```
+
+See [the routing guide](docs/routing.md) for authentication hooks, scopes,
+namespaces, shallow routes and custom action mappings.
+
+## Errors and request limits
+
+JSON bodies must be objects. Malformed JSON and malformed query inputs produce
+400. Bodies above 1 MiB produce 413, including bodies without a content length;
+`max_body_bytes` configures the limit.
+
+`MK::BadRequest`, `MK::Unauthorized`, `MK::Forbidden`, `MK::NotFound`,
+`MK::Conflict`, `MK::ValidationError` and `MK::BadGateway` represent intentional
+public errors. Their messages are public, so never put secrets in them.
+Unexpected errors return JSON with `error: "Server error"` and a request ID.
+The same ID appears in `X-Request-ID` and the structured error log.
 
 Production is the safe default. Set `RACK_ENV=development` explicitly for debug
 details. Configure a logger using `configure logger: Logger.new($stdout)`, or

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

@@ -1,13 +1,13 @@
 source 'https://rubygems.org'
 
 gem 'mk_framework', '~> <%= MK::VERSION %>'
+gem 'puma', '~> 8.0'
+gem 'rackup', '~> 2.3'
+gem 'rake', '~> 13.4'
 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'
+  gem 'rspec', '~> 3.13'
 end

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

@@ -8,7 +8,8 @@ module <%= config.namespace %>
   class <%= config.action_prefix %><%= action.capitalize %>Controller < MK::Controller
     route do |r|
 <% if action == 'index' -%>
-      <%= config.model_class %>.order(:id)
+      page = r.page
+      <%= config.model_class %>.order(:id).limit(page[:limit], page[:offset])
 <% elsif %w[show delete].include?(action) -%>
       <%= config.model_class %>[r.path_params.fetch(:id)] or raise MK::NotFound
 <% else -%>

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

@@ -12,6 +12,6 @@ module <%= config.namespace %>
        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')))
+                             pool_timeout: Integer(ENV.fetch('DB_POOL_TIMEOUT', '5')))
        end
 end

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

@@ -7,15 +7,15 @@ module <%= config.namespace %>
 
     def validate
       super
-      validates_not_null %i[<%= config.field_names.join(' ') %>]
+      validates_not_null <%= config.field_names.map(&:to_sym).inspect %>
 <% 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(' ') %>]
+      validates_presence <%= text_fields.map(&:to_sym).inspect %>
 <% end -%>
     end
 
     def self.public_attributes_list
-      %i[id <%= config.field_names.join(' ') %> created_at updated_at]
+      <%= ([:id] + config.field_names.map(&:to_sym) + [:created_at, :updated_at]).inspect %>
     end
   end
 end

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

@@ -1,23 +1,33 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper'
+<% if config.namespace == config.model_class -%>
 
-RSpec.describe '<%= config.model_class %> CRUD' do
+module <%= config.namespace %>
+<% end -%>
+
+describe '<%= config.model_class %> CRUD' do
   include Rack::Test::Methods
 
   let(:app) { Rack::Builder.parse_file(File.join(<%= config.namespace %>::ROOT, 'config.ru')) }
   let(:attributes) { JSON.parse(<%= config.example.to_json.inspect %>) }
 
   before do
-    <%= config.namespace %>::<%= config.model_class %>.dataset.delete
+    <%= config.model_class %>.dataset.delete
     header 'CONTENT_TYPE', 'application/json'
   end
 
-  it 'persists permitted fields and returns a 201 response through the Rack entrypoint' do
+  def create_record
+    post('/<%= config.resource %>', attributes.to_json)
+    expect(last_response.status).to eq(201)
+    JSON.parse(last_response.body).fetch('<%= config.model_name %>')
+  end
+
+  it 'creates a record with POST /<%= config.resource %>' do
     post('/<%= config.resource %>', attributes.merge('id' => 999).to_json)
 
     expect(last_response.status).to eq(201)
-    record = <%= config.namespace %>::<%= config.model_class %>.first
+    record = <%= config.model_class %>.first
     expect(record).not_to be_nil
     expect(record.id).not_to eq(999)
     payload = JSON.parse(last_response.body).fetch('<%= config.model_name %>')
@@ -25,37 +35,18 @@ RSpec.describe '<%= config.model_class %> CRUD' do
     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
-    post('/<%= config.resource %>', {}.to_json)
-
-    expect(last_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] %>'] = []
-    post('/<%= config.resource %>', attributes.to_json)
-
-    expect(last_response.status).to eq(400)
-    expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(0)
-  end
-
-  def create_record
-    post('/<%= config.resource %>', attributes.to_json)
-    expect(last_response.status).to eq(201)
-    JSON.parse(last_response.body).fetch('<%= config.model_name %>')
-  end
-
-  it 'lists records in ID order, including an empty collection' do
+  it 'lists records with GET /<%= config.resource %>' do
     get('/<%= config.resource %>')
     expect(JSON.parse(last_response.body)).to eq('<%= config.resource %>' => [])
-    records = [create_record, create_record]
+    records = [create_record, create_record, create_record]
     get('/<%= config.resource %>')
     expect(last_response.status).to eq(200)
     expect(JSON.parse(last_response.body).fetch('<%= config.resource %>')).to eq(records)
+    get('/<%= config.resource %>?limit=1&offset=1')
+    expect(JSON.parse(last_response.body).fetch('<%= config.resource %>')).to eq([records[1]])
   end
 
-  it 'shows a single record' do
+  it 'shows a record with GET /<%= config.resource %>/:id' do
     record = create_record
     get("/<%= config.resource %>/#{record.fetch('id')}")
     expect(last_response.status).to eq(200)
@@ -63,11 +54,10 @@ RSpec.describe '<%= config.model_class %> CRUD' do
   end
 
 <% updated_value = { 'string' => 'Updated', 'text' => 'Updated text', 'integer' => 2, 'float' => 2.5, 'boolean' => true, 'date' => '2027-02-03', 'datetime' => '2027-02-03T14:30:00Z' }.fetch(config.fields.first[:type]) -%>
-  it 'updates permitted fields with PUT, preserving omitted fields and the ID' do
+  it 'updates a record with PUT /<%= config.resource %>/:id' do
     record = create_record
     changes = { '<%= config.fields.first[:name] %>' => <%= updated_value.inspect %>, 'id' => 999 }
-    put("/<%= config.resource %>/#{record.fetch('id')}",
-      changes.to_json)
+    put("/<%= config.resource %>/#{record.fetch('id')}", changes.to_json)
     expect(last_response.status).to eq(200)
     payload = JSON.parse(last_response.body).fetch('<%= config.model_name %>')
     expect(payload.fetch('id')).to eq(record.fetch('id'))
@@ -79,36 +69,22 @@ RSpec.describe '<%= config.model_class %> CRUD' do
     expect(payload.except('<%= config.fields.first[:name] %>', 'updated_at')).to eq(record.except('<%= config.fields.first[:name] %>', 'updated_at'))
     get("/<%= config.resource %>/#{record.fetch('id')}")
     expect(JSON.parse(last_response.body).fetch('<%= config.model_name %>')).to eq(payload)
-    expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(1)
-  end
+    expect(<%= config.model_class %>.count).to eq(1)
 
-  it 'rejects invalid updates without changing stored data' do
-    record = create_record
-    <%= %w[string text].include?(config.fields.first[:type]) ? "[[[], 400], [nil, 400], ['', 422]]" : '[[[], 400], [nil, 400]]' %>.each do |value, status|
-      put("/<%= config.resource %>/#{record.fetch('id')}",
-        { '<%= config.fields.first[:name] %>' => value }.to_json)
-      expect(last_response.status).to eq(status)
-      get("/<%= config.resource %>/#{record.fetch('id')}")
-      expect(JSON.parse(last_response.body).fetch('<%= config.model_name %>')).to eq(record)
-    end
+    put("/<%= config.resource %>/#{record.fetch('id')}", { '<%= config.fields.first[:name] %>' => [] }.to_json)
+    expect(last_response.status).to eq(400)
+    get("/<%= config.resource %>/#{record.fetch('id')}")
+    expect(JSON.parse(last_response.body).fetch('<%= config.model_name %>')).to eq(payload)
   end
 
-  it 'deletes a record and returns its public attributes' do
+  it 'deletes a record with DELETE /<%= config.resource %>/:id' do
     record = create_record
     delete("/<%= config.resource %>/#{record.fetch('id')}")
     expect(last_response.status).to eq(200)
     expect(JSON.parse(last_response.body).fetch('<%= config.model_name %>')).to eq(record)
-    expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(0)
-    get("/<%= config.resource %>/#{record.fetch('id')}")
-    expect(last_response.status).to eq(404)
-  end
-
-  %w[get put delete].each do |verb|
-    it "returns 404 for #{verb.upcase} of a missing record" do
-      public_send(verb, '/<%= config.resource %>/999999',
-        attributes.to_json)
-      expect(last_response.status).to eq(404)
-      expect(<%= config.namespace %>::<%= config.model_class %>.count).to eq(0)
-    end
+    expect(<%= config.model_class %>.count).to eq(0)
   end
 end
+<% if config.namespace == config.model_class -%>
+end
+<% end -%>

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

@@ -9,6 +9,8 @@ require_relative '../database'
 Sequel::Migrator.run(<%= config.namespace %>::DB, File.join(<%= config.namespace %>::ROOT, 'db/migrations'))
 require_relative '../app'
 
+include <%= config.namespace %>
+
 RSpec.configure do |config|
   config.after(:suite) { <%= config.namespace %>::DB.disconnect }
 end

data/lib/mk_framework/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mk_framework
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Francesco Canessa