Created a TqCheck system which is similar but backwards incompatible to the TqValidation framework. The new implementation

• is more supportive of the Kotlin idioms
• allows for type-safety referencing of data model fields
• supports message templating and the ability to custom define rendering rules (defaults to {{bean.dot.notation}} syntax)
• enables checking only if defined for all checks
• supports uuid and objectid checks in addition to the original validation checks
• augmented email validation to support a larger variety of TLD
• ability to retrieve a raw field value during the checks
• and many more improvements

Also including in this are

• deprecation of the TqCache and the promotion of TqLoadingCache (aka TqCaffeine) which is far suprior in all ways
• removal of the deprecated "spark" module. Javalin is the preferred implementation choice
• upgradies to various dependencies including kotlin to version 1.5.0

Of important notice, this will likely be the last feature release on the JVM 8 platform. The intention is for future version to be baselined against the JVM 11 platform.

Now there is an ability to select for a CachedRowSet instead of always having to do an immediate lamda handling of the ResultSet.

Also ResultSet now have a .forEach extension to make utilizing them more kotlinized as well.

Deprecated the entire tekniq-spark project and recommend using Javalin instead for this aspect of the system.

• Allow defaulting the validation src to null rather then explicitly forcing the user to do so. This makes it a bit easier and prettier to work with when tossing fixed validation errors.
• Fixed merging of validations to include the internal tested and passed counters in order to provide accurate metrics.
• Added a new "with" support to allow for strongly typed checks to take place using the also new "check" validation that allows freeform use of anything returning a Boolean to be used as the determination of a validation.
• Loosened up some validation internals to allow for subclassing of validation and customizations to take place to better tune it for specific project needs (like Javalin integration).

Also other changes include

• Upgraded to Kotlin 1.3.61 (from 1.3.50)
• Upgraded to Jackson 2.9.10 (from 2.9.8)
• Deprecated TqCache promoting use of the superior TqCaffeine instead. Will probably merge tekniq-cache into the -core project at some point and make the TqCache a wrapper around the TqCaffeine on the next feature version bump.
• Added another classpath detection routine for the TqPropertiesConfig. This is to help better support some of the changes that occur with classpath support during Java 11+.

Often times internal organizations are using self-signed certificates but have multiple DNS names mapped to the system. The request is that it is not any less risky to allow mismatched hostnames because they are only used for internal communication channels anyway.

Fixed but that caused the year to be 1900 years into the future.

It's a common thing especially in enterprise code to communicate with servers that are self-signed. You do still trust the server in question but you don't wish to completely ignore all certificate checking across all of the url connections. Thus this feature was added to allow for improved usability of restful connections without exposing security concerns across an application.

Also properly handles Sparklin outputting of Iterables.

Validation framework improvements for "arrayOf" types.

• Upgraded Kotlin to 1.2.21 (from 1.1.51)
• Upgraded Jackson to 2.9.4 (from 2.8.9)
• Upgraded Spark to 2.7.1 (from 2.6.0)
• Compile code target for 1.8 (instead of 1.6)

Forcefully rollback a transaction if an exception occurs within the transaction if and only if the transaction is suppose to auto-commit (default behavior).

Added missing 401 handling support to the TqSparklin implementation

• New JsonRequestValidation for Request based validations
• Clean migration strategy to TqSparklin (lighter and faster then the deprecated Sparklin)
• halt() moved into the Route level for better practical usability
• Added afterAfter which is equivalent to a finally block in java's try/catch world.
• Added notFound() which hooks into the native notFound / 404 page situations
• Added ability to move static resources to be handled after filters have been applied. This allows you to do additional logic if desired even around static resources (like password protect /admin pages).
• Renamed several classes to have a Tq prefix to them for consistency (left aliases for original names but in a deprecated status to help ease migrations).
• Various minor bugfixes

Breaking Changes

• TqCache interface changed to be a MutableMap type and has remove() instead of invalidate() now.
• TqCache interface changed to correctly map to Map type's get() method (which returns nullable element).

New Features

• Incorporated Caffeine as an alternative caching solution in the form of TqCaffeine (tekniq-cache module).
• TqCache and TqCaffeine caching solutions interface behind TqCacheMap which extends MutableMap now.
• Validation added support for string length (min and max ranges).
• Added TqSparklin which is a light-weight alternative to Sparklin. It does not support the integration of Authentication or Validation framework and intended for those with stringent performance requirements.

Enhancements

• Caching of web request body to enable proper validation usage with Sparklin. Containers such as Tomcat do not allow multiple reads of the body otherwise.
• Improved TqCache concurrency.
• ValidationException message now shows error codes.
• Updated various dependencies (could not update spark-java as version 2.6.0 breaks with exception handling under high load)

• Updated to kotlin 1.1.2-3
• TqCache no longer forces nullable value types. Must be explicitly defined as nullable value to accept null values now. This is best practice.
• TqPropertiesConfig now properly handles a missing classpath error in an easier to comprehend manner and only stops if the stopOnFailure is set to true.
• TqCache now evicts the oldest created entry if over the max limit. Previously was evicting the first key it found.
• Explicitly declared and forced java 8 target binaries. No longer (probably) works for Java 6 and 7. This was always intended to be the case but now utilizing kotlin's jre8 features so explicitly forcing it to prevent unsupported side effects.

• Added TqCron to allow cron job calculations
• Migrated Validation API from Sparklin module to Core module (by popular demand as it is applicable outside of webapps and has no dependencies on anything else)
• Added "email()" validation to the Validation API
• Adjusted the Sparklin Validations authz() to be easier to use (breaks backwards compatibility due to parameter reordering)
• Fixed Sparklin to support non-object JSON payloads (such as image uploads or xml data)
• Added ifDefined and ifNotDefined to Sparklin Validation to make it easier to do things if and only if a parameter was defined or not defined. This is very helpful for supporting optional parameters but still be statically bound to a (data) class backing object.
• Added requiredOrNull validation so that it is only required if a non-null value is given (not an empty list or blank string for example)
• jsonAs extension is no longer "nullable" (extreme edge case almost never used and can be worked around if absolutely needed)
• Allow for reconfiguration of the Sparklin Object Mapper
• Sparklin handles "Unit" or "empty" data types as a 204 success no content response instead of a 200 with an empty object.
• Sparklin Enhancements to allow for use inside a web container such as content (doesn't have to be a stand alone application anymore but still can be with trivial changes)
• Updated to kotlin 1.1.x

• Added ResultSet extensions to tekniq-jdbc for reading nullable primitives
• RestClient supports lambda response handling

• insertReturnKey() will do the same thing as insert but will also get the generated key and return it as well in the form of a String. This is because some systems will use a String as the id (such as Oracle).
• transaction will now allow returning a value back out. This prevents the hackish paradigm of creating a var defaulting to null and then in the transaction setting the desired value and so forth. Cleans up the codebase a good bit.
• transaction will now default to commiting at the end instead of doing a rollback. This helps keep things cleaner and easier to understand but a commitOnCompletion flag can be passed in to revert it back to the rollback state if desired.

• TqChainConfig now correctly does contain check on all references.
• All TqConfig children inherit the String to Number feature.
• Fixed issue with TqMapConfig breaking after the design change of it.

• Added Chain Configurations to support concepts such as reading from a global configuration and allowing a local configuration overrides.
• Improved Date and Time handling (including new Java 8 LocalDate/Time) in JDBC auto params.
• Properties Configuration can now read both files as well as classpath items. Classpath items are prepended with classpath:
• Map based configurations will now auto-convert strings into number types when using the getInt/Long/etc ... methods.
• Environmental configurations preload all environments now instead of only pulling it in during access. This allows for the "keys" iteration to work as one might expect.