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
intIntegerinteger
longLong bigint
floatDoubledouble precision
doubleDoubledouble precision
decimalBigDecimalnumeric
numericBigDecimalnumeric
textStringtext or varcharvarchar if there is a length constraint
stringStringtext or varcharvarchar if there is a length constraint
charStringchar(1)
booleanBooleanBoolean
dateDate timestamp with time zonejavaxt.utils.Date
binarybyte[]bytea
jsonJSONObjectjasonbjavaxt.json.JSONObject
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)

Notes:

  • 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}
        ]
    }
}

Dependencies

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.

License

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
  <repositories>
    <repository>
      <id>javaxt.com</id>
      <url>https://www.javaxt.com/maven</url>
    </repository>
  </repositories>
Add Maven Dependency
  <dependencies>
    <dependency>
      <groupId>javaxt</groupId>
      <artifactId>javaxt-orm</artifactId>
      <version>1.1.0</version>
    </dependency>
  </dependencies>