Object Relational Mapping

The javaxt-orm library is a handy tool for generating Java code and DDL from a set of models defined in a Javascript or JSON document. The generated classes are used to persist data in a relational database via the javaxt.sql.Model class.

Download javaxt-orm
Current Version: 1.1.0
Release Date: 5/21/2023
File Size: 36 KB
File Format: Zip
Includes: Jar File, Binaries, Source Code, and Documentation

Key Features

  • Auto-generate database schema and Java classes
  • Command line interface
  • Supports spatial geometry types with JTS
  • Plug and play with javaxt-core and javaxt-express
  • Supports common RDMBS (PostgreSQL, H2, etc)

Note that this is not intended to be a full fledged ORM framework. Instead, the goal is to help jumpstart new projects by providing a simple utility for stubbing out code and SQL.

Basic Usage

The javaxt-orm library provides a command line interface that can be used to generate Java classes and schema. All you need to do is provide a input model and an output directory. Example:

java -jar javaxt-orm.jar /path/to/model.js /output

Model Input

Below is a simple example of an input Javascript file with an Address model.
var package = "com.example.models";
var models = {
    Address: {
        fields: [
            {name: 'street',        type: 'string'},
            {name: 'city',          type: 'string'},
            {name: 'state',         type: 'string'},
            {name: 'postalCode',    type: 'string'},
            {name: 'coordinates',   type: 'geo'}

The full list of field types are listed below.

In addition to the standard field types, you can specify a model as a `type`. In the example below, the address field in the Contact model is a `Address` type.

  Contact: {
     fields: [
        {name: 'name', type: 'string'},
        {name: 'address', type: 'Address'}
  Address: {

Model mapping and supported types

Field TypeJava TypeDatabase TypeComments
longLong bigint
floatDoubledouble precision
doubleDoubledouble precision
textStringtext or varcharvarchar if there is a length constraint
stringStringtext or varcharvarchar if there is a length constraint
dateDate timestamp with time zonejavaxt.utils.Date
geoGeometrygeometry(Geometry,4326)For lat/lon geographic data. Geometry is found in the JTS package.
geometryGeometrygeometry(GeometryZ)For x,y,z data. Geometry is found in the JTS package.
passwordStringtextStores bcrypt hash in the database (vs plaintext password)


  • IDs are automatically added so you don't have to explicitly define one in the model.
  • Models can be assigned to fields. A foreign key will be created in the database.
  • lastUpdate fields in the model are automatically assigned a trigger in the database.

Supported field constraints

Constraint KeyTypeComments
requiredbooleanIf true, adds a "NOT NULL" constraint to the field. Can also use "nullable" keyword.
lengthintOnly applies to "text" field types. Reassigns the database type to varchar.
uniquebooleanIf true, adds a "UNIQUE" constraint to the field. Should NOT be applied to "text" fields without a length constraint.
onDeletestringOnly applies to fields with models. Options include "cascade" and "no action" (default).

The following is an example of a "User" model with constraints defined for several fields (e.g. username, password, active):

    User: {
        fields: [
            {name: 'username',    type: 'string'},
            {name: 'password',    type: 'password'},
            {name: 'accessLevel', type: 'int'},
            {name: 'active',      type: 'boolean'},
            {name: 'contact',     type: 'Contact'},
            {name: 'auth',        type: 'json'}
        constraints: [
            {name: 'username',   required: true,  length: 255,  unique: true},
            {name: 'password',   required: true},
            {name: 'active',     required: true}
        defaults: [
            {name: 'active',    value: true}


The javaxt-orm library is compiled using Java 11 requires the following libraries:
  • Nashorn for Javascript parsing
  • javaxt-core for JSON and basic file IO

Generated Code Dependencies

The javaxt-orm library generates Java code that extends/implements javaxt.sql.Model class. It also calls java.util.Map.ofEntries which was introduced in Java 9. Therefore, you will need both javaxt-core and Java 9 (or higher) to use the generated code in your project. In addition, you will need JTS if you include a `geo` or `geometry` type. Last but not least, you will need to include a JDBC driver in your project for persistance.


All JavaXT libraries are free and open source released under a permissive MIT license. This software comes with no guarantees or warranties. You may use this software in any open source or commercial project.

Maven Support

If you're a Maven user, you can configure your pom.xml to pull releases directly from this site. To add javaxt-orm to your project, simply add this site to your list of repositories and add a dependency. XML snippits below. See the downloads page for more information.
Add Maven Repository
Add Maven Dependency