praxis 2.0.pre.31 → 2.0.pre.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b0d313f269a5d2eee55bec87524dc37d0b424ed747969fa35f3f8454e658028
-  data.tar.gz: 894589492bcd9d0cd1c8af237215892e163c9229f6f81a6aa90a709b43623a25
+  metadata.gz: 481a1aedfa10aa914a0b0bba13a1b39ca3de5d9ecfd3840520674919fc82563e
+  data.tar.gz: 7796b1d757c700cb9e56a9d16f1471ef5930ee0fe19b3b596d948a9a8b7f8b3c
 SHA512:
-  metadata.gz: 1744d64f7e8521185d687cc124c8b553b297f79734c74b0bffb83bab7a5f8bdbacf1e71899ffce8044fddbf1d92902270fae4892425808aaedc6eff7a2490f61
-  data.tar.gz: c5602b15ddf593f4b387f39c398fd411158e2b936e5763a21cf01edb86c3ea4c87f3a09f95c5fa2bff29317075ebae6bbec52eba5190b9594359e335e14ef23f
+  metadata.gz: 91b4c7f698267e0a533ccc1ba73e500ed2c9570550b83dacee4cc1ff80bd615e55b66bfd9707ba25c05b38599a98da2661505aec15e96def2d0ae1b3f94f2b6e
+  data.tar.gz: c21b5bed2302eba252b58fa78da841c82227994796344eacc0d2b9c20608d166e3f9e5fd3e5bb73c2fa191b909891c5d901627832de94a4a594ee085be3f26b6

data/.gitignore

@@ -3,6 +3,7 @@ coverage
 Gemfile.lock
 _site/
 .sass-cache/
+.vscode
 
 .data/
 .tmp/
@@ -15,4 +16,4 @@ lib/api_browser/app/bower_components/
 lib/api_browser/.tmp/
 lib/api_browser/bower.json
 
-development.sqlite3
+development.sqlite3

data/CHANGELOG.md

@@ -2,143 +2,175 @@
 
 ## next
 
+## 2.0.pre.32
+- Spruced up the scaffolding generation, to be more configurable using a `.praxis_scaffold` file at the root, where one can specify things like
+  the base module for all generated classes (`base`), the path of the models directory (`models_dir`) and the version to use (`version`). These, except the models directory can also be passed and overriden by command line arguments (and they would be saved into the config file to be usable in future invocations)
+- More efficient validation of Blueprint structures
+- Fix pseudo bug where the field expander capped subfields as soon as it encountered a type without explicit attributes (i.e., Hash). Instead, it allows any of the subfields to percolate through.
+- OpenApi generation improvements:
+  - Add global parameters for versioning (ApiVersionHeader and ApiVersionParam) appropriately if the API is versioned by them. Have actions point to these definitions by $ref
+  - Expect the 'server' definition in the APIDefinition to contain url/description and 'variables' sections which might define variables in the server url
+
 ## 2.0.pre.31
-  * Switch the locally generated index.html file to browse the generated OpenAPI docs to use `elements` instead of `reDoc`
-  * Spruce up the initial Gemfile for the generated example app
-  * Fix Praxis::Mapper ordering code, to not prefix top level columns with the table name, as this completely confuses ActiveRecord which switches to full-on eager loading all of the associations in the top query. i.e., passing an invalid table/column name in a `references` method will trigger that (seemingly a current bug)
+
+- Switch the locally generated index.html file to browse the generated OpenAPI docs to use `elements` instead of `reDoc`
+- Spruce up the initial Gemfile for the generated example app
+- Fix Praxis::Mapper ordering code, to not prefix top level columns with the table name, as this completely confuses ActiveRecord which switches to full-on eager loading all of the associations in the top query. i.e., passing an invalid table/column name in a `references` method will trigger that (seemingly a current bug)
 
 ## 2.0.pre.30
-  * A few cleanup and robustness additions:
-    * OpenAPI: Disable overriding a description when the schema is a ref (there are known issues with UI browsers)
-    * Internal: use `_pk` in batch processor invocation instead of `id` (resources will now have a `_pk` method which defaults to `id`)
-    * Bumped gemspec Ruby dependency to >=2.7 (but note, that this is just a little relaxed for older codebase, we're fully building for 3.x)
-  * Backwards incompatible changes:
-    * Enforces property names are symbols (before strings were allowed)
-    * Resource properties, using the `as:` option, are now enforced to be real association names (will not accept other resource names and unroll their dependencies)
-    * Deprecated the `:through` option for a property. You can just use `as:` with a long, dot-separated association path directly.
-  * Enhanced ordering semantics for pagination to allow for sorting of deep associated fields:
-    * Right now, you can sort by fields such as `books.author.name` as one of the sorting components (with `+` or `-` still available)
-  * Introduced better attribute grouping concepts, that help in defining subgroups of attributes of the same object, and allow lazy loading of only partial subsets so that one can have expensive computations on some of them, but they will never be invoked unless necessary. See MediaType.`group` and Resoruce.`property_group` explanations below.
-  * Introduced a 'group' stanza in MediaTypes, to specify a structure of attributes that exist in the main object, but that we want to neatly expose as a subset (instead of having them unrolled at the top):
-    * You can now use things like `group subinfo do ... end` blocks, defining which attributes to group
-    * Internal: Underneath, the system will create a BlueprintAttributeGroup (instead of a Struct) as a way to ensure that only the individual attributes that need to be rendered, are accessed (and not load the whole struct at once). While the behavior, to the outside, is gonna be identical to a Struct (i.e., exposes attributes as methods), this distinct object implementation is very important as it allows you to have attributes in the subgroup that are expensive to compute, and can be rest assured that they will not be accessed/computed unless they are required for rendering.
-  * Introduced the `property_group` stanza in resources, to indicate that a property contains a substructure of attributes, each of which must be able to be loaded only when necessary. This commonly goes hand in hand with a `group` stanza in the resource's MediaType:
-    * Usage of property group requires the name of the substructure (a symbol), and the associated mediatype that contains the definition of the `group` struct, under the same name of the property.
-    * Internally, this stanza, will define a normal property, and include as dependencies all of the sub attributes read from the MediaType's property, but appending the name (and `_`) to them to avoid collisions.
-    * Also, it will define a method with the property name which will return a Forwarding object, which will delegate each of the attribute methods back to the original self objects. This allows the object to avoid being 'loaded' as a whole as it happens with Struct, therefore only materializing/calling the attribute that we actually need to use, selectively.
-    * For example, if we have the `Book` MediaType which has a group atrribute called `subinfo` with a few attributes (like `name` and `pages`), we can use `property_group :subinfo, Book` on its domain object, so that the system will:
-      * define a `subinfo` property which will depend on `subinfo_name` and `subinfo_pages`
-      * define a `subinfo` method that will return a Forwarding object, that will forward `name` and `pages` methods to `subinfo_name` and `subinfo_pages` methods of the self resource.
-      * with that, we just need to define our `subinfo_name` and `subinfo_page` methods in the resource (and also define property dependencies for them if we need to)
+
+- A few cleanup and robustness additions:
+  - OpenAPI: Disable overriding a description when the schema is a ref (there are known issues with UI browsers)
+  - Internal: use `_pk` in batch processor invocation instead of `id` (resources will now have a `_pk` method which defaults to `id`)
+  - Bumped gemspec Ruby dependency to >=2.7 (but note, that this is just a little relaxed for older codebase, we're fully building for 3.x)
+- Backwards incompatible changes:
+  - Enforces property names are symbols (before strings were allowed)
+  - Resource properties, using the `as:` option, are now enforced to be real association names (will not accept other resource names and unroll their dependencies)
+  - Deprecated the `:through` option for a property. You can just use `as:` with a long, dot-separated association path directly.
+- Enhanced ordering semantics for pagination to allow for sorting of deep associated fields:
+  - Right now, you can sort by fields such as `books.author.name` as one of the sorting components (with `+` or `-` still available)
+- Introduced better attribute grouping concepts, that help in defining subgroups of attributes of the same object, and allow lazy loading of only partial subsets so that one can have expensive computations on some of them, but they will never be invoked unless necessary. See MediaType.`group` and Resoruce.`property_group` explanations below.
+- Introduced a 'group' stanza in MediaTypes, to specify a structure of attributes that exist in the main object, but that we want to neatly expose as a subset (instead of having them unrolled at the top):
+  - You can now use things like `group subinfo do ... end` blocks, defining which attributes to group
+  - Internal: Underneath, the system will create a BlueprintAttributeGroup (instead of a Struct) as a way to ensure that only the individual attributes that need to be rendered, are accessed (and not load the whole struct at once). While the behavior, to the outside, is gonna be identical to a Struct (i.e., exposes attributes as methods), this distinct object implementation is very important as it allows you to have attributes in the subgroup that are expensive to compute, and can be rest assured that they will not be accessed/computed unless they are required for rendering.
+- Introduced the `property_group` stanza in resources, to indicate that a property contains a substructure of attributes, each of which must be able to be loaded only when necessary. This commonly goes hand in hand with a `group` stanza in the resource's MediaType:
+  - Usage of property group requires the name of the substructure (a symbol), and the associated mediatype that contains the definition of the `group` struct, under the same name of the property.
+  - Internally, this stanza, will define a normal property, and include as dependencies all of the sub attributes read from the MediaType's property, but appending the name (and `_`) to them to avoid collisions.
+  - Also, it will define a method with the property name which will return a Forwarding object, which will delegate each of the attribute methods back to the original self objects. This allows the object to avoid being 'loaded' as a whole as it happens with Struct, therefore only materializing/calling the attribute that we actually need to use, selectively.
+  - For example, if we have the `Book` MediaType which has a group atrribute called `subinfo` with a few attributes (like `name` and `pages`), we can use `property_group :subinfo, Book` on its domain object, so that the system will:
+    - define a `subinfo` property which will depend on `subinfo_name` and `subinfo_pages`
+    - define a `subinfo` method that will return a Forwarding object, that will forward `name` and `pages` methods to `subinfo_name` and `subinfo_pages` methods of the self resource.
+    - with that, we just need to define our `subinfo_name` and `subinfo_page` methods in the resource (and also define property dependencies for them if we need to)
 
 ## 2.0.pre.29
-  * Assorted set of fixes to generate cleaner and more compliant OpenApi documents.
-    * Mostly in the area of multipart generation, and requirements and nullability for OpenApi 3.0
+
+- Assorted set of fixes to generate cleaner and more compliant OpenApi documents.
+  - Mostly in the area of multipart generation, and requirements and nullability for OpenApi 3.0
+
 ## 2.0.pre.28
-  * Enhance the mapper's Resource property to allow for a couple more powerful options using the `as:` keyword:
-    * `as: :self` will provide a way to map any further incoming fields on top of the already existing object. This is useful when we want to expose some properties for a resource, grouped within a sub structure, but that in reality they exist directly in the resource's underlying model (i.e., to organize the information of the model in a more structured/groupable way).
-    * `as: 'association1.association2'` allows us to traverse more than 1 association, and continue applying the incoming fields under that. This is commonly used when we want to expose a relationship on a resource, which is really coming from more than a single association level depth.
+
+- Enhance the mapper's Resource property to allow for a couple more powerful options using the `as:` keyword:
+  - `as: :self` will provide a way to map any further incoming fields on top of the already existing object. This is useful when we want to expose some properties for a resource, grouped within a sub structure, but that in reality they exist directly in the resource's underlying model (i.e., to organize the information of the model in a more structured/groupable way).
+  - `as: 'association1.association2'` allows us to traverse more than 1 association, and continue applying the incoming fields under that. This is commonly used when we want to expose a relationship on a resource, which is really coming from more than a single association level depth.
+
 ## 2.0.pre.27
-  * Introduce a new `as:` option for resource's `property`, to indicate that the underlying association method it is connected to, has a different name.
-    * This also will create a delegation function for the property name, that instead of calling the underlying association on the record, and wrapping the result with a resource instance, it will simply call the aliased method name (which is likely gonna hit the autogenerated code for that properyty, unless we have overriden it)
-    * With this change, the selector generator (i.e., the thing that looks at the incoming `fields` parameters and calculates which select and includes are necessary to query all the data we need), will be able to understand this aliasing cases, and properly pass along, and continue expanding any nested fields that are under the property name (before this, and further inner fields would be not included as soon as we hit a property that didn't have that direct association underneath).
+
+- Introduce a new `as:` option for resource's `property`, to indicate that the underlying association method it is connected to, has a different name.
+  - This also will create a delegation function for the property name, that instead of calling the underlying association on the record, and wrapping the result with a resource instance, it will simply call the aliased method name (which is likely gonna hit the autogenerated code for that properyty, unless we have overriden it)
+  - With this change, the selector generator (i.e., the thing that looks at the incoming `fields` parameters and calculates which select and includes are necessary to query all the data we need), will be able to understand this aliasing cases, and properly pass along, and continue expanding any nested fields that are under the property name (before this, and further inner fields would be not included as soon as we hit a property that didn't have that direct association underneath).
 
 ## 2.0.pre.26
-  * Make POST action forwarding more robust against technically malformed GET requests with no body but passing `Content-Type`. This could cause issues when using the `enable_large_params_proxy_action` DSL.
+
+- Make POST action forwarding more robust against technically malformed GET requests with no body but passing `Content-Type`. This could cause issues when using the `enable_large_params_proxy_action` DSL.
 
 ## 2.0.pre.25
-  * Improve surfacing of requirement attributes in Structs for OpenApi generated documentation
-  * Introduction of a new dsl `enable_large_params_proxy_action` for GET verb action definitions. When used, two things will happen:
-    * A new POST verb equivalent action will be defined:
-      * It will have a `payload` matching the shape of the original GET's params (with the exception of any param that was originally in the URL)
-      * By default, the route for this new POST request is gonna have the same URL as the original GET action, but appending `/actions/<action_name>` to it. This can be customized by passing the path with the `at:` parameter of the DSL. I.e., `enable_large_params_proxy_action at: /actions/myspecialname` will change the generated path (can use the `//...` syntax to not include the prefix defined for the endpoint). NOTE: this route needs to be compatible with any params that might be defined for the URL (i.e., `:id` and such).
-      * This action will be fully visible and fully documented in the API generated docs. However, it will not need to have a corresponding controller implementation since it will special-forward it to the original GET action switching the parameters for the payload.
-    * Specifically, upon receiving a request to the POST equivalent action, Praxis will detect it is a special action and will:
-      * use directly the original action (i.e., will do the before/after filters and call the controller's method)
-      * will load the parameters for the action from the incoming payload
-    * This functionality is to allow having a POST counterpart to any GET requests that require long query strings, and for which the client cannot use a payload bodies (i.e,. Browser JS clients cannot send payload on GET requests).
-  * Performance improvement:
-    * Cache praxis associations' computation for ActiveRecord (so no communication with AR or DB happens after that)
-  * Performance improvement: Use OJ as the (faster) default JSON renderer.
-  * Introduce batch computation of resource attributes: This defines an optional DSL (`batch_computed`) to enable easier calculation of expensive attributes that can be calculated much more efficiently in group:
-    * The new DSL takes an attribute name (Symbol), options and an implementation block that is able to get a list of resource instances (a hash of them, indexed by id) and perform the computation for all of them at once.
-    * Defining an attribute this way, resources can be used to be much more efficiently to calculate values that can be retrieved much more efficiently in bulk, and/or that depend on other resources of the same type to do so (i.e., things that to calculate that attribute for one single resource can be greatly amortized by doing it for many).
-    * The provided block to calculate the value of the attribute for a collection of resources of the same type is stored as a method inside an inner module of the resource class called BatchProcessors
-    * The class level method is callable through `::BatchProcessors.<property_name>(rows_by_id: xxx)`. The rows_by_id: parameter has resource 'ids' as keys, and the resource instances themselves a values
-    * By default an instance method of the same `<property_name>` name will also be created, with a default implementation that will call the `BatchProcessor.<property_name>` with only its instance id and instance, and will return only its result from it.
-    * If creating the helper instance method is not desired, one can pass `with_instance_method: false` when defining the batched_computed block. This might be necessary if we want to define the method ourselves, or in cases where the resource itself has an 'id' property that is not called 'id' (in which case the implementation would not be correct as it uses the `id` property of the resource). If that's the case, disable the creation, and add your own instance method that uses the defined BatchProcessor method passing the right parameters.
-    * It is also possible to query which attributes for a resource class are batch computed. This is done through .batched_attributes (which returns and array of symbol names)
-    * NOTE: Defining batch_computed attributes needs to be done before finalization
+
+- Improve surfacing of requirement attributes in Structs for OpenApi generated documentation
+- Introduction of a new dsl `enable_large_params_proxy_action` for GET verb action definitions. When used, two things will happen:
+  - A new POST verb equivalent action will be defined:
+    - It will have a `payload` matching the shape of the original GET's params (with the exception of any param that was originally in the URL)
+    - By default, the route for this new POST request is gonna have the same URL as the original GET action, but appending `/actions/<action_name>` to it. This can be customized by passing the path with the `at:` parameter of the DSL. I.e., `enable_large_params_proxy_action at: /actions/myspecialname` will change the generated path (can use the `//...` syntax to not include the prefix defined for the endpoint). NOTE: this route needs to be compatible with any params that might be defined for the URL (i.e., `:id` and such).
+    - This action will be fully visible and fully documented in the API generated docs. However, it will not need to have a corresponding controller implementation since it will special-forward it to the original GET action switching the parameters for the payload.
+  - Specifically, upon receiving a request to the POST equivalent action, Praxis will detect it is a special action and will:
+    - use directly the original action (i.e., will do the before/after filters and call the controller's method)
+    - will load the parameters for the action from the incoming payload
+  - This functionality is to allow having a POST counterpart to any GET requests that require long query strings, and for which the client cannot use a payload bodies (i.e,. Browser JS clients cannot send payload on GET requests).
+- Performance improvement:
+  - Cache praxis associations' computation for ActiveRecord (so no communication with AR or DB happens after that)
+- Performance improvement: Use OJ as the (faster) default JSON renderer.
+- Introduce batch computation of resource attributes: This defines an optional DSL (`batch_computed`) to enable easier calculation of expensive attributes that can be calculated much more efficiently in group:
+  - The new DSL takes an attribute name (Symbol), options and an implementation block that is able to get a list of resource instances (a hash of them, indexed by id) and perform the computation for all of them at once.
+  - Defining an attribute this way, resources can be used to be much more efficiently to calculate values that can be retrieved much more efficiently in bulk, and/or that depend on other resources of the same type to do so (i.e., things that to calculate that attribute for one single resource can be greatly amortized by doing it for many).
+  - The provided block to calculate the value of the attribute for a collection of resources of the same type is stored as a method inside an inner module of the resource class called BatchProcessors
+  - The class level method is callable through `::BatchProcessors.<property_name>(rows_by_id: xxx)`. The rows_by_id: parameter has resource 'ids' as keys, and the resource instances themselves a values
+  - By default an instance method of the same `<property_name>` name will also be created, with a default implementation that will call the `BatchProcessor.<property_name>` with only its instance id and instance, and will return only its result from it.
+  - If creating the helper instance method is not desired, one can pass `with_instance_method: false` when defining the batched_computed block. This might be necessary if we want to define the method ourselves, or in cases where the resource itself has an 'id' property that is not called 'id' (in which case the implementation would not be correct as it uses the `id` property of the resource). If that's the case, disable the creation, and add your own instance method that uses the defined BatchProcessor method passing the right parameters.
+  - It is also possible to query which attributes for a resource class are batch computed. This is done through .batched_attributes (which returns and array of symbol names)
+  - NOTE: Defining batch_computed attributes needs to be done before finalization
 
 ## 2.0.pre.24
- Assorted set of fixes and cleanup:
-  * better forwarding signature for query methods
-  * Fix the way with which to decide how to wrap an association (based on Enumerable isn't right, as Hashes are Enumerable as well). Wrapping decision
-    is now made based on the association type, and not the shape of the resulting type.
-  * Built handling of some multivalue and/or fuzzy matching cases in filtering params
-  * unrestrict mustermann's dependent version
-  * Support options and even passing a full type (instead of a block) in signature definitions (TypedMethods for resources)
+
+Assorted set of fixes and cleanup:
+
+- better forwarding signature for query methods
+- Fix the way with which to decide how to wrap an association (based on Enumerable isn't right, as Hashes are Enumerable as well). Wrapping decision
+  is now made based on the association type, and not the shape of the resulting type.
+- Built handling of some multivalue and/or fuzzy matching cases in filtering params
+- unrestrict mustermann's dependent version
+- Support options and even passing a full type (instead of a block) in signature definitions (TypedMethods for resources)
 
 ## 2.0.pre.22
-  * Small fix in OpenAPI doc generation, which would detect and report more output types, even if they are only defined within the
-    children of anonymous types.
+
+- Small fix in OpenAPI doc generation, which would detect and report more output types, even if they are only defined within the
+  children of anonymous types.
 
 ## 2.0.pre.22
-  * Introduced Resource callbacks (an includeable concern). Callbacks allow you to define methods or blocks to be executed `before`, `after` or `around` any existing method in the resource. Class-level callbacks are defined with `self.xxxxx`. These methods will be executed within the instance of the resource (i.e., in the same context of the original) and must be defined with the same parameter signature. For around methods, only blocks can be used, and to call the original (inner) one, one needs to yield.
-  * Introduced QueryMethods for resources (an includeable concern). QueryMethods expose handy querying methods (`.get`, `.get!`, `.all`, `.first` and `.last` ) which will reach into the underlying ORM (i.e., right now, only ActiveModelCompat is supported) to perform the desired loading of data (and subsequent wrapping of results in resource instances).
-    * For ActiveRecord `.get` takes a condition hash that will translate to `.find_by`, and `.all` gets a condition hash that will translate to `.where`. 
-    * `.get!` is a `.get` but that will raise a `Praxis::Mapper::ResourceNotFound` exception if nothing was found.
-    * There is an `.including(<spec>)` function that can be use to preload the underlying associations. I.e., the `<spec>` argument will translate to `.includes(<spec>)` in ActiveRecord.
-  * Introduced method signatures and validations for resources.
-    * One can define a method signature with the `signature(<name>)` stanza, passing a block defining Attributor parameters. For instance method signatures, the `<name>` is just a symbol with the name of the method. For class level methods use a string, and prepend `self.` to it (i.e., `self.create`).
-    * Signatures can only work for methods that either have a single argument (taken as a whole hash), or that have only keyword arguments (i.e., no mixed args and kwargs). It would be basically impossible to validate that combo against an Attributor Struct.
-    * The calls to typed methods will be intercepted (using an around callback), and the incoming parameters will be validated against the Attributor Struct defined in the siguature, coerced if necessary and passed onto the original method. If the incoming parameters fail validation, a `IncompatibleTypeForMethodArguments` exception will be thrown.
+
+- Introduced Resource callbacks (an includeable concern). Callbacks allow you to define methods or blocks to be executed `before`, `after` or `around` any existing method in the resource. Class-level callbacks are defined with `self.xxxxx`. These methods will be executed within the instance of the resource (i.e., in the same context of the original) and must be defined with the same parameter signature. For around methods, only blocks can be used, and to call the original (inner) one, one needs to yield.
+- Introduced QueryMethods for resources (an includeable concern). QueryMethods expose handy querying methods (`.get`, `.get!`, `.all`, `.first` and `.last` ) which will reach into the underlying ORM (i.e., right now, only ActiveModelCompat is supported) to perform the desired loading of data (and subsequent wrapping of results in resource instances).
+  - For ActiveRecord `.get` takes a condition hash that will translate to `.find_by`, and `.all` gets a condition hash that will translate to `.where`.
+  - `.get!` is a `.get` but that will raise a `Praxis::Mapper::ResourceNotFound` exception if nothing was found.
+  - There is an `.including(<spec>)` function that can be use to preload the underlying associations. I.e., the `<spec>` argument will translate to `.includes(<spec>)` in ActiveRecord.
+- Introduced method signatures and validations for resources.
+  - One can define a method signature with the `signature(<name>)` stanza, passing a block defining Attributor parameters. For instance method signatures, the `<name>` is just a symbol with the name of the method. For class level methods use a string, and prepend `self.` to it (i.e., `self.create`).
+  - Signatures can only work for methods that either have a single argument (taken as a whole hash), or that have only keyword arguments (i.e., no mixed args and kwargs). It would be basically impossible to validate that combo against an Attributor Struct.
+  - The calls to typed methods will be intercepted (using an around callback), and the incoming parameters will be validated against the Attributor Struct defined in the siguature, coerced if necessary and passed onto the original method. If the incoming parameters fail validation, a `IncompatibleTypeForMethodArguments` exception will be thrown.
 
 ## 2.0.pre.21
-  * Fix nullable attribute in OpenApi generation
+
+- Fix nullable attribute in OpenApi generation
+
 ## 2.0.pre.20
-* Changed the behavior of dev-mode when validate_responses. Now they return a 500 status code (instead of a 400) but with the same validation error format body.
-  * validate_responses is meant to catch the application returning non-compliant responses for development only. As such, a 500 is much more appropriate and clear, as the validation is done on the behavior of the server, and not on the information sent by the client (i.e., it is a server problem, not reacting the way the API is defined)
-* Introduced a method to reload a Resouce (.reload), which will clear the memoized values and call record.reload as well
-* Open API Generation enhancements:
-  * Fixed type discovery (where some types wouldn't be included in the output)
-  * Changed the generation to output named types into components, and use `$ref` to point to them whenever appropriate
-  * Report nullable attributes
+
+- Changed the behavior of dev-mode when validate_responses. Now they return a 500 status code (instead of a 400) but with the same validation error format body.
+  - validate_responses is meant to catch the application returning non-compliant responses for development only. As such, a 500 is much more appropriate and clear, as the validation is done on the behavior of the server, and not on the information sent by the client (i.e., it is a server problem, not reacting the way the API is defined)
+- Introduced a method to reload a Resouce (.reload), which will clear the memoized values and call record.reload as well
+- Open API Generation enhancements:
+  - Fixed type discovery (where some types wouldn't be included in the output)
+  - Changed the generation to output named types into components, and use `$ref` to point to them whenever appropriate
+  - Report nullable attributes
+
 ## 2.0.pre.19
-* Introduced a new DSL for the `FilteringParams` type that allows filters for common attributes in your Media Types:
-  * The new `any` DSL allows you to define which final leaf attribute to always allow, and with which operators and/or fuzzy restrictions.
-  * For example, you can add `any updated_at, using: ['>','<']` which would allow the type to accept filters like `updated_at>2000-01-01`, or any existing nested fields like `posts.comments.updated_at>2000-01-01`
-  * Note that the path of attributes passed in, will still need to exist and will be validated. Also, you still need to make sure that you have the right `filters_mapping` defined in your resources.
-* Changed `filters_mapping` to allow implicitly any filter path that is a valid representation of existing columns and associations. I.e., you do not have to explicitly define long nested filters that correspond to the same underlying path of associations and columns.
+
+- Introduced a new DSL for the `FilteringParams` type that allows filters for common attributes in your Media Types:
+  - The new `any` DSL allows you to define which final leaf attribute to always allow, and with which operators and/or fuzzy restrictions.
+  - For example, you can add `any updated_at, using: ['>','<']` which would allow the type to accept filters like `updated_at>2000-01-01`, or any existing nested fields like `posts.comments.updated_at>2000-01-01`
+  - Note that the path of attributes passed in, will still need to exist and will be validated. Also, you still need to make sure that you have the right `filters_mapping` defined in your resources.
+- Changed `filters_mapping` to allow implicitly any filter path that is a valid representation of existing columns and associations. I.e., you do not have to explicitly define long nested filters that correspond to the same underlying path of associations and columns.
+
 ## 2.0.pre.18
-* Upgraded to newest Attributor, which cleans up the required: true semantics to only work on keys, and introduces null: true for nullability of values (independent from presence of keys or not)
-* Fixed a selector generator bug that would occur when using deep nested resource dependencies as strings 'foo.bar.baz.bam'. In this cases only partial tracking of relationships would be built, which could cause to not fully eager load DB queries.
+
+- Upgraded to newest Attributor, which cleans up the required: true semantics to only work on keys, and introduces null: true for nullability of values (independent from presence of keys or not)
+- Fixed a selector generator bug that would occur when using deep nested resource dependencies as strings 'foo.bar.baz.bam'. In this cases only partial tracking of relationships would be built, which could cause to not fully eager load DB queries.
+
 ## 2.0.pre.17
-* Changed the Parameter Filtering to use left outer joins (and extra conditions), to allow for the proper results when OR clauses are involved in certain configurations.
-* Built support for allowing filtering directly on associations using `!` and `!!` operators. This allows to filter results where 
-there are no associated rows (`!!`) or if there are some associated rows (`!`)
-* Allow implicit definition of `filters_mapping` for filter names that match top-level associations of the model (i.e., like we do for the columns)
+
+- Changed the Parameter Filtering to use left outer joins (and extra conditions), to allow for the proper results when OR clauses are involved in certain configurations.
+- Built support for allowing filtering directly on associations using `!` and `!!` operators. This allows to filter results where
+  there are no associated rows (`!!`) or if there are some associated rows (`!`)
+- Allow implicit definition of `filters_mapping` for filter names that match top-level associations of the model (i.e., like we do for the columns)
+
 ## 2.0.pre.16
 
-* Updated `Resource.property` signature to only accept known named arguments (`dependencies` and `though` at this time) to spare anyone else from going insane wondering why their `depednencies` aren't working.
-* Fixed issue with Filtering Params, that occurred with using the ! or !! operators on String-typed fields.
+- Updated `Resource.property` signature to only accept known named arguments (`dependencies` and `though` at this time) to spare anyone else from going insane wondering why their `depednencies` aren't working.
+- Fixed issue with Filtering Params, that occurred with using the ! or !! operators on String-typed fields.
 
 ## 2.0.pre.14
 
-* More encoding/decoding robustness for filters. 
-  * Specs for how to encode filters are now properly defined by:
-    * The "value" of the filters query string needs to be URI encoded (like any other query string value). This encoding is subject to the normal rules, and therefore "could" leave some of the URI unreserved characters (i.e., 'markers') unencoded depending on the client (Section 2.2 of https://tools.ietf.org/html/rfc2396).
-    * The "values" for any of the conditions in the contents of the filters, however, will need to be properly "escaped" as well (prior to URL-encoding the whole syntax string itself like described above). This means that any match value needs to ensure that it has (at least) "(",")","|","&" and "," escaped as they are reserved characters for the filter expression syntax. For example, if I want to search for a name with value "Rocket&(Pants)", I need to first compose the syntax by: "name=<escaped Rocket&(Pants)>, which is "name=Rocket%26%28Pants%29" and then, just URI encode that query string value for the filters parameter in the URL like any other. For example: "filters=name%3DRocket%2526%2528Pants%2529"
-    * When using a multi-match (csv-separated) list of values, you need to escape each of the values as well, leaving the 'comma' unescape, as that's part of the syntax. Then uri-encode it all for the filters query string parameter value like above.
-  * Now, one can properly differentiate between fuzzy query prefix/postfix, and the literal data to search for (which can be or include '*'). Report that multi-matches (i.e., csv separated values for a single field, which translate into "IN" clauses) is not allowed if fuzzy matches are received (need to use multiple OR clauses for it).
+- More encoding/decoding robustness for filters.
+  - Specs for how to encode filters are now properly defined by:
+    - The "value" of the filters query string needs to be URI encoded (like any other query string value). This encoding is subject to the normal rules, and therefore "could" leave some of the URI unreserved characters (i.e., 'markers') unencoded depending on the client (Section 2.2 of https://tools.ietf.org/html/rfc2396).
+    - The "values" for any of the conditions in the contents of the filters, however, will need to be properly "escaped" as well (prior to URL-encoding the whole syntax string itself like described above). This means that any match value needs to ensure that it has (at least) "(",")","|","&" and "," escaped as they are reserved characters for the filter expression syntax. For example, if I want to search for a name with value "Rocket&(Pants)", I need to first compose the syntax by: "name=<escaped Rocket&(Pants)>, which is "name=Rocket%26%28Pants%29" and then, just URI encode that query string value for the filters parameter in the URL like any other. For example: "filters=name%3DRocket%2526%2528Pants%2529"
+    - When using a multi-match (csv-separated) list of values, you need to escape each of the values as well, leaving the 'comma' unescape, as that's part of the syntax. Then uri-encode it all for the filters query string parameter value like above.
+  - Now, one can properly differentiate between fuzzy query prefix/postfix, and the literal data to search for (which can be or include '\*'). Report that multi-matches (i.e., csv separated values for a single field, which translate into "IN" clauses) is not allowed if fuzzy matches are received (need to use multiple OR clauses for it).
 
 ## 2.0.pre.13
 
-* Fix filters parser regression, which would incorrectly decode url-encoded values
+- Fix filters parser regression, which would incorrectly decode url-encoded values
 
 ## 2.0.pre.12
 
-* Rebuilt API filters to support a much richer syntax. One can now use ANDs and ORs (with ANDs having order precedence), as well as group them with parenthesis. The same individual filter operands are supported. For example: 'email=*@gmail.com&(friends.first_name=Joe*,Patty|friends.last_name=Smith)
+- Rebuilt API filters to support a much richer syntax. One can now use ANDs and ORs (with ANDs having order precedence), as well as group them with parenthesis. The same individual filter operands are supported. For example: 'email=_@gmail.com&(friends.first_name=Joe_,Patty|friends.last_name=Smith)
 
 ## 2.0.pre.11
 
@@ -152,7 +184,7 @@ there are no associated rows (`!!`) or if there are some associated rows (`!`)
 - Simple, but pervasive breaking change: Rename `ResourceDefinition` to `EndpointDefinition` (but same functionality).
 - Remove all deprecated features (and raise error describing it's not supported yet)
 - Remove `Links` and `LinkBuilder`. Those seem unnecessary from a Framework point of view as they aren't clear most
-applications would benefit from it. Applications can choose to add that functionality on their own if so desire.
+  applications would benefit from it. Applications can choose to add that functionality on their own if so desire.
 - Rebuilt app generators: for new empty app, and example app.
 - Updated default layout to match new naming structure and more concepts commonly necessary for normal applications.
 - Completely removed the native Praxis API documentation browser in lieu of OpenAPI 3.x standards, and reDoc.
@@ -190,6 +222,7 @@ applications would benefit from it. Applications can choose to add that function
 - Added support for OpenAPI 3.x document generation. Consider this in Beta state, although it is fairly close to feature complete.
 
 ## 2.0.pre.4
+
 - Reworked the field selection DB query generation to support full tree of eager loaded dependencies
   - Built support for both ActiveRecord and Sequel gems
   - Selected DB fields will include/map the defined resource properties and will always include any necessary fields on both sides of the joins for the given associations.

data/bin/praxis

@@ -47,6 +47,8 @@ path_to_loader = format('%<path>s/tasks/loader.thor', path: path_to_praxis)
 load path_to_loader
 
 class PraxisGenerator < Thor
+  SCAFFOLD_CONFIG_FILE = "#{Dir.pwd}/.praxis_scaffold"
+
   # Include a few fake thor action descriptions (for the rake tasks above) so they can show up in the same usage messages
   desc 'routes [json]', 'Prints the route table of the application. Defaults to table format, but can produce json'
   def routes; end
@@ -91,7 +93,9 @@ class PraxisGenerator < Thor
   # Cannot use the argument below or it will apply to all commands (the action in the class has it)
   # argument :collection_name, required: false
   # The options, however, since they're optional are fine (But need to be duplicated from the class :( )
-  option :version, required: false, default: '1',
+  option :base, required: false,
+                desc: 'Module name to enclose all generated files. Empty by default. You can pass things like MyApp, or MyApp::SubModule'
+  option :version, required: false,
                    desc: 'Version string for the API endpoint. This also dictates the directory structure (i.e., v1/endpoints/...))'
   option :design, type: :boolean, default: true,
                   desc: 'Include the Endpoint and MediaType files for the collection'
@@ -120,6 +124,25 @@ class PraxisGenerator < Thor
     opts = { orm: options[:model] }
     opts[:orm] = 'activerecord' if opts[:orm] == 'model' # value is model param passed by no value
     ::PraxisGen::Model.new([collection_name.singularize], opts).invoke(:g)
+    self.class.save_scaffolding_config
+  end
+
+  # Read and pass the hash around in the class, so callers can read and modify it if desired
+  # Final contents will be saved at the end of scaffolding generation
+  def self.scaffold_config
+    return @current_config if @current_config
+
+    @current_config = File.exist?(SCAFFOLD_CONFIG_FILE) ? JSON.parse(File.read(SCAFFOLD_CONFIG_FILE), symbolize_names: true) : {}
+  end
+
+  def self.save_scaffolding_config
+    if File.exist?(SCAFFOLD_CONFIG_FILE)
+      contents_from_file = JSON.parse(File.read(SCAFFOLD_CONFIG_FILE), symbolize_names: true)
+      return if contents_from_file == @current_config
+    end
+
+    puts "Saving new scaffolding config into #{SCAFFOLD_CONFIG_FILE}"
+    File.write(SCAFFOLD_CONFIG_FILE, JSON.pretty_generate(scaffold_config))
   end
 
   # Initially, the idea was to build some quick model generator, but I think it's better to keep it

data/lib/praxis/application.rb

@@ -40,7 +40,7 @@ module Praxis
     end
 
     def inspect
-      "<#{self.class}##{object_id} root: #{@root}>"
+      "#<#{self.class}##{object_id} @root=#{@root}>"
     end
 
     def setup(root: '.')

data/lib/praxis/blueprint.rb

@@ -333,23 +333,31 @@ module Praxis
       errors = []
       keys_provided = []
 
-      self.class.attributes.each do |key, attribute|
-        sub_context = self.class.generate_subcontext(context, key)
-        value = _get_attr(key)
-        keys_provided << key if @object.key?(key)
+      keys_provided = object.contents.keys
 
-        next if value.respond_to?(:validating) && value.validating # really, it's a thing with sub-attributes
+      keys_provided.each do |key|
+        sub_context = self.class.generate_subcontext(context, key)
+        attribute = self.class.attributes[key]
 
-        # Isn't this handled by the requirements validation? NO! we might want to combine
-        errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."] if attribute.options[:required] && !@object.key?(key)
-        if @object[key].nil?
-          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."] if !Attributor::Attribute.nullable_attribute?(attribute.options) && @object.key?(key) # It is only nullable if there's an explicite null: true (undefined defaults to false)
+        if object.contents[key].nil?
+          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."] if !Attributor::Attribute.nullable_attribute?(attribute.options) && object.contents.key?(key) # It is only nullable if there's an explicite null: true (undefined defaults to false)
           # No need to validate the attribute further if the key wasn't passed...(or we would get nullable errors etc..cause the attribute has no
           # context if its containing key was even passed (and there might not be a containing key for a top level attribute anyways))
         else
+          value = _get_attr(key)
+          next if value.respond_to?(:validating) && value.validating # really, it's a thing with sub-attributes
+
           errors.concat attribute.validate(value, sub_context)
         end
       end
+
+      leftover = self.class.attributes.keys - keys_provided
+      leftover.each do |key|
+        attribute = self.class.attributes[key]
+
+        errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."] if attribute.options[:required]
+      end
+
       self.class.attribute.type.requirements.each do |requirement|
         validation_errors = requirement.validate(keys_provided, context)
         errors.concat(validation_errors) unless validation_errors.empty?

data/lib/praxis/controller.rb

@@ -35,6 +35,10 @@ module Praxis
       @response = response
     end
 
+    def inspect
+      "#<#{self.class}##{object_id} @request=#{@request.inspect}>"
+    end
+
     def definition
       self.class.definition
     end

data/lib/praxis/docs/open_api/operation_object.rb

@@ -31,6 +31,15 @@ module Praxis
             # security: [{}]
             # servers: [{}]
           }
+
+          # Handle versioning header/params for the action in a special way, by linking to the existing component
+          # spec that will be generated globally
+          api_info = ApiDefinition.instance.infos[action.endpoint_definition.version]
+          if (version_with = api_info.version_with)
+            all_parameters.push('$ref' => '#/components/parameters/ApiVersionHeader') if version_with.include?(:header)
+            all_parameters.push('$ref' => '#/components/parameters/ApiVersionParam') if version_with.include?(:params)
+          end
+
           h[:description] = action.description if action.description
           h[:tags] = all_tags.uniq unless all_tags.empty?
           h[:parameters] = all_parameters unless all_parameters.empty?

data/lib/praxis/docs/open_api/paths_object.rb

@@ -32,14 +32,14 @@ module Praxis
           id = resource.id
           # fill in the paths hash with a key for each path for each action/route
           resource.actions.each do |action_name, action|
-            params_example =  action.params ? action.params.example(nil) : nil
+            params_example = action.params ? action.params.example(nil) : nil
             url = ActionDefinition.url_description(route: action.route, params: action.params, params_example: params_example)
 
             verb = url[:verb].downcase
             templetized_path = OpenApiGenerator.templatize_url(url[:path])
             path_entry = paths[templetized_path]
             # Let's fill in verb stuff within the working hash
-            raise "VERB #{_verb} already defined for #{id}!?!?!" if path_entry[verb]
+            raise "VERB #{verb} already defined for #{id}!?!?!" if path_entry[verb]
 
             action_uid = "action-#{action_name}-#{id}"
             # Add a tag matching the resource name (hoping all actions of a resource are grouped)

data/lib/praxis/docs/open_api_generator.rb

@@ -109,7 +109,15 @@ module Praxis
 
         info_object = OpenApi::InfoObject.new(version: version, api_definition_info: @infos[version])
         # We only support a server in Praxis ... so we'll use the base path
-        server_object = OpenApi::ServerObject.new(url: @infos[version].base_path)
+        server_params = {}
+        if(server_info = @infos[version].server)
+          server_params[:url] = server_info[:url]
+          server_params[:variables] = server_info[:variables] if server_info[:variables]
+        else
+          server_params[:url] = @infos[version].base_path
+        end
+        server_params[:description] = server_info[:description] if server_info[:description]
+        server_object = OpenApi::ServerObject.new(**server_params)
 
         paths_object = OpenApi::PathsObject.new(resources: resources_by_version[version])
 
@@ -151,6 +159,28 @@ module Praxis
           schemas: component_schemas
         }
 
+        # Common params/headers for versioning (actions will link to them when appropriate, by name)
+        if (version_with = @infos[version].version_with)
+          common_params = {}
+          if version_with.include?(:header)
+            common_params['ApiVersionHeader'] = { 
+              in: 'header',
+              name: 'X-Api-Version',
+              schema: { type: 'string', enum: [version]},
+              required: version_with.size == 1
+            }
+          end
+          if version_with.include?(:params)
+            common_params['ApiVersionParam'] = { 
+              in: :query,
+              name: 'api_version',
+              schema: { type: 'string', enum: [version]},
+              required: version_with.size == 1
+            }
+          end
+          full_data[:components][:parameters] = common_params
+        end
+
         # REDOC specific grouping of sidebar
         resource_tags = { name: 'Resources', tags: tags_for_resources.map { |t| t[:name] } }
         schema_tags = { name: 'Models', tags: tags_for_mts.map { |t| t[:name] } }
@@ -170,26 +200,26 @@ module Praxis
         converted_full_data = JSON.parse(json_data) # So symbols disappear
         File.open("#{filename}.yml", 'w') { |f| f.write(YAML.dump(converted_full_data)) }
 
-        html = <<-HTML
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-    <title>Elements in HTML</title>
-  
-    <script src="https://unpkg.com/@stoplight/elements/web-components.min.js"></script>
-    <link rel="stylesheet" href="https://unpkg.com/@stoplight/elements/styles.min.css">
-  </head>
-  <body>
-
-    <elements-api
-      apiDescriptionUrl="http://localhost:9090/#{version_file}/openapi.json"
-      router="hash"
-    />
-
-  </body>
-</html>
+        html = <<~HTML
+          <!doctype html>
+          <html lang="en">
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+              <title>Elements in HTML</title>
+          #{'  '}
+              <script src="https://unpkg.com/@stoplight/elements/web-components.min.js"></script>
+              <link rel="stylesheet" href="https://unpkg.com/@stoplight/elements/styles.min.css">
+            </head>
+            <body>
+
+              <elements-api
+                apiDescriptionUrl="http://localhost:9090/#{version_file}/openapi.json"
+                router="hash"
+              />
+
+            </body>
+          </html>
         HTML
         html_file = File.join(doc_root_dir, version_file, 'index.html')
         File.write(html_file, html)

data/lib/praxis/field_expander.rb

@@ -68,7 +68,7 @@ module Praxis
       end
 
       # just include the full thing if it has no attributes
-      return true if object.attributes.empty?
+      return fields if object.attributes.empty?
 
       # True, expands to the default fieldset for blueprints
       fields = object.default_fieldset if object < Praxis::Blueprint && fields == true

data/lib/praxis/mapper/selector_generator.rb

@@ -321,7 +321,7 @@ module Praxis
       end
 
       def inspect
-        "<#{self.class}# @root=#{@root.inspect}>"
+        "#<#{self.class} @resource=#{@resource.name.inspect} @select=#{@select.inspect} @select_star=#{@select_star.inspect} @tracking.keys=#{@tracks.keys} (recursion omitted)>"
       end
     end
 

data/lib/praxis/request.rb

@@ -184,7 +184,7 @@ module Praxis
     # Override the inspect instance method of a request, as, by default, the kernel inspect will go nuts
     # traversing the action and app_instance and therefore all associated instance variables reachable through that
     def inspect
-      "'@env' => #{@env.inspect},\n'@headers' => #{@headers.inspect},\n'@params' => #{@params.inspect},\n'@query' => #{@query.inspect}"
+      "#<#{self.class}##{object_id} @action=#{@action.inspect} @params=#{@params.inspect}>"
     end
   end
 end

data/lib/praxis/tasks/console.rb

@@ -27,6 +27,9 @@ namespace :praxis do
       PROMPT_C: "%N(#{nickname}):%03n:%i* "
     }
 
+    # Disable inefficient, distracting autocomplete
+    IRB.conf[:USE_AUTOCOMPLETE] = false
+
     # Set the IRB main object.
     IRB.irb(nil, Praxis::Application.instance)
   end

data/lib/praxis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Praxis
-  VERSION = '2.0.pre.31'
+  VERSION = '2.0.pre.32'
 end

data/spec/praxis/application_spec.rb

@@ -97,6 +97,17 @@ describe Praxis::Application do
     end
   end
 
+  describe '#inspect' do
+    let(:klass) { Class.new(Praxis::Application) }
+    subject { klass.instance }
+
+    it 'includes name, object ID and root' do
+      SomeApplication = klass # de-anonymize class name
+      klass.instance.instance_variable_set(:@root, '/tmp')
+      expect(subject.inspect).to match(%r{#<SomeApplication#[0-9]+ @root=/tmp>})
+    end
+  end
+
   describe '#setup' do
     subject { Class.new(Praxis::Application).instance }
 

data/spec/praxis/blueprint_spec.rb

@@ -166,6 +166,12 @@ describe Praxis::Blueprint do
       it { should be_empty }
     end
 
+    context 'with a valid nested blueprint' do
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob'}} }
+
+      it { should be_empty }
+    end
+
     context 'with invalid sub-attribute' do
       let(:hash) { { name: 'bob', address: { state: 'ME' } } }
 
@@ -173,6 +179,15 @@ describe Praxis::Blueprint do
       its(:first) { should =~ /Attribute \$.address.state/ }
     end
 
+    context 'with an invalid nested blueprint' do
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob', address: { state: 'ME' }}} }
+
+      it { should have(1).item }
+      its(:first) { should =~ /Attribute \$.myself.address.state/ }
+
+    end
+
+
     context 'for objects of the wrong type' do
       it 'raises an error' do
         expect do

data/spec/praxis/controller_spec.rb

@@ -31,4 +31,13 @@ describe Praxis::Controller do
       expect(subject).to eq(PeopleResource.controller)
     end
   end
+
+  describe '#inspect' do
+    it 'includes name, object ID and request' do
+      SomeController = subject # de-anonymize class name
+      expect(subject.new('eioio').inspect).to match(
+        /#<SomeController#[0-9]+ @request="eioio">/
+      )
+    end
+  end
 end

data/spec/praxis/request_spec.rb

@@ -146,6 +146,16 @@ describe Praxis::Request do
     end
   end
 
+  context '#inspect' do
+    it 'includes action and params' do
+      request.action = 'eioio'
+      request.params = 'zzyzx'
+      expect(request.inspect).to match(
+        /#<Praxis::Request#[0-9]+ @action="eioio" @params="zzyzx">/
+      )
+    end
+  end
+
   context '#load_headers' do
     it 'is done preserving the original case' do
       request.load_headers(context[:headers])

data/tasks/thor/model.rb

@@ -13,6 +13,8 @@ module PraxisGen
     argument :model_name, required: true
     option :orm, required: false, default: 'activerecord', enum: %w[activerecord sequel]
     def g
+      models_dir = 'app/models'
+      models_dir = PraxisGenerator.scaffold_config[:models_dir] if PraxisGenerator.scaffold_config[:models_dir]
       # self.class.check_name(model_name)
       template_file = \
         if options[:orm] == 'activerecord'
@@ -21,7 +23,7 @@ module PraxisGen
           'models/sequel.rb'
         end
       puts "Generating Model for #{model_name}"
-      template template_file, "app/models/#{model_name}.rb"
+      template template_file, "#{models_dir}/#{model_name}.rb"
       nil
     end
     # Helper functions (which are available in the ERB contexts)

data/tasks/thor/scaffold.rb

@@ -13,7 +13,9 @@ module PraxisGen
 
     desc 'g', 'Generates an API design and implementation scaffold for managing a collection of <collection_name>'
     argument :collection_name, required: true
-    option :version, required: false, default: '1',
+    option :base, required: false,
+                  desc: 'Module name to enclose all generated files. Empty by default. You can pass things like MyApp, or MyApp::SubModule'
+    option :version, required: false,
                      desc: 'Version string for the API endpoint. This also dictates the directory structure (i.e., v1/endpoints/...))'
     option :design, type: :boolean, default: true,
                     desc: 'Include the Endpoint and MediaType files for the collection'
@@ -26,6 +28,11 @@ module PraxisGen
     option :actions, type: :string, default: 'crud', enum: %w[cr cru crud u ud d],
                      desc: 'Specifies the actions to generate for the API. cr=create, u=update, d=delete. Index and show actions are always generated'
     def g
+      incorporate_config_options
+      # Good defaults
+      options[:version] = '1' unless options[:version].presence
+      options[:models_dir] = 'app/models' unless options[:models_dir]
+
       self.class.check_name(collection_name)
       @actions_hash = self.class.compose_actions_hash(options[:actions])
       env_rb = Pathname.new(destination_root) + Pathname.new('config/environment.rb')
@@ -53,10 +60,31 @@ module PraxisGen
         template 'implementation/controllers/collection.rb', "app/#{version_dir}/controllers/#{collection_name}.rb"
       end
       nil
+      save_last_config_options
     end
 
     # Helper functions (which are available in the ERB contexts)
     no_commands do
+      def incorporate_config_options
+        @saved_original_options = options
+        self.options = options.dup
+        return if PraxisGenerator.scaffold_config.empty?
+
+        begin
+          options[:base] = PraxisGenerator.scaffold_config[:base] unless PraxisGenerator.scaffold_config[:base].presence
+          options[:version] = PraxisGenerator.scaffold_config[:version] unless PraxisGenerator.scaffold_config[:version].presence
+          options[:models_dir] = PraxisGenerator.scaffold_config[:models_dir] if PraxisGenerator.scaffold_config[:models_dir]
+        rescue StandardError # rubocop:disable Lint/SuppressedException
+        end
+      end
+
+      def save_last_config_options
+        return if @saved_original_options.slice('base', 'version').empty?
+
+        opts_to_save = options.slice('base', 'version').transform_keys(&:to_sym).reject { |_k, v| v.nil? }
+        PraxisGenerator.scaffold_config.merge!(opts_to_save)
+      end
+
       def plural_class
         collection_name.camelize
       end
@@ -65,16 +93,20 @@ module PraxisGen
         collection_name.singularize.camelize
       end
 
+      def base_module
+        options[:base]
+      end
+
       def version
         options[:version]
       end
 
       def version_module
-        "V#{version}"
+        base_module.presence ? "#{base_module}::V#{version}" : "V#{version}"
       end
 
       def version_dir
-        version_module.camelize(:lower)
+        "v#{version}"
       end
 
       def action_enabled?(action)

data/tasks/thor/templates/generator/scaffold/design/endpoints/collection.rb

@@ -77,6 +77,7 @@ module <%= version_module %>
           # attribute :name
         end
         response :no_content
+        response :not_found
         response :bad_request
       end
       <%- end -%>

data/tasks/thor/templates/generator/scaffold/design/media_types/item.rb

@@ -5,7 +5,7 @@ module <%= version_module %>
     class <%= singular_class %> < Praxis::MediaType
       identifier 'application/json'
 
-      domain_model '<%= version_module %>::Resources::<%= singular_class %>'
+      domain_model 'Resources::<%= singular_class %>'
       description 'Structural definition of a <%= singular_class %>'
 
       attributes do

data/tasks/thor/templates/generator/scaffold/implementation/controllers/collection.rb

@@ -11,7 +11,7 @@ module <%= version_module %>
       # Retrieve all <%= plural_class %> with the right necessary associations
       # and render them appropriately with the requested field selection
       def index
-        objects = build_query(model_class).all
+        objects = build_query(model_class)
         display(objects)
       end
       <%- end -%>
@@ -42,14 +42,12 @@ module <%= version_module %>
       <%- if action_enabled?(:update) -%>
       # Updates some of the information of a <%= singular_class %>
       def update(id:)
-        # A good pattern is to call the same name method on the corresponding resource, 
-        # passing the incoming id and payload (or massaging it first)
-        updated_resource = Resources::<%= singular_class %>.update(
-          id: id,
-          payload: request.payload,
-        )
-        return Praxis::Responses::NotFound.new unless updated_resource
+        # A good pattern is to retrieve the resource instance by id, and then
+        # call the same name method on it, by passing the incoming payload (or massaging it first)
+        resource = Resources::<%= singular_class %>.get(id: id)
+        return Praxis::Responses::NotFound.new unless resource
 
+        resource.update(payload: request.payload)
         Praxis::Responses::NoContent.new
       end
       <%- end -%>
@@ -57,13 +55,12 @@ module <%= version_module %>
       <%- if action_enabled?(:delete) -%>
       # Deletes an existing <%= singular_class %>
       def delete(id:)
-        # A good pattern is to call the same name method on the corresponding resource,
-        # maybe passing the already loaded model
-        deleted_resource = Resources::<%= singular_class %>.delete(
-          id: id
-        )
-        return Praxis::Responses::NotFound.new unless deleted_resource
+        # A good pattern is to retrieve the resource instance by id, and then
+        # call the same name method on it
+        resource = Resources::<%= singular_class %>.get(id: id)
+        return Praxis::Responses::NotFound.new unless resource
 
+        resource.delete(payload: request.payload)
         Praxis::Responses::NoContent.new
       end
       <%- end -%>

data/tasks/thor/templates/generator/scaffold/implementation/resources/item.rb

@@ -22,21 +22,17 @@ module <%= version_module %>
       <%- end -%>
 
       <%- if action_enabled?(:update) -%>
-      def self.update(id:, payload:)
-        record = model.find_by(id: id)
-        return nil unless record
+      def update(payload:)
         # Assuming the API field names directly map the the model attributes. Massage if appropriate.
         record.update(**payload.to_h)
-        self.new(record)
+        self
       end
       <%- end -%>
 
       <%- if action_enabled?(:delete) -%>
       def self.delete(id:)
-        record = model.find_by(id: id)
-        return nil unless record
         record.destroy
-        self.new(record)
+        self
       end
       <%- end -%>  
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.31
+  version: 2.0.pre.32
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-07 00:00:00.000000000 Z
+date: 2023-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport