model-redis 0.2.1 → 0.4.0

package/README.md

@@ -1,34 +1,67 @@
 # Model Redis
 
-Simple ORM model for Redis in NodsJS. The only external dependence is `redis`.
-This provides a simple ORM interface, with schema, for Redis. This is not meant 
+Simple ORM model for Redis in Node.js. The only external dependency is `redis`.
+This provides a simple ORM interface, with schema, for Redis. This is not meant
 for large data sets and is geared more for small, internal infrastructure based
-projects that do not require complex data model.
+projects that do not require complex data models.
 
+## Features
 
-## Getting started
+- 📦 **CommonJS & ESM compatible** - Works seamlessly with both module systems
+- 📋 Schema-based validation with type checking
+- 🔑 Primary key and indexed field support
+- 🔗 Model relationships (one-to-one, one-to-many)
+- 🔄 Automatic type conversion (Redis strings ↔ native types)
+- 🛡️ Field privacy control (exclude sensitive data from JSON)
+- 🧪 Fully tested with 84%+ code coverage
+- 🏷️ Key prefixing support
 
-`setUpTable([object])` -- *Function* to bind the Redis connection
-	object to the ORM table. It takes an optional connected redis client object
-	or configuration for the Redis module. This will return a `Table` class we
-	can use later for our model.
+## Installation
 
-It is recommend you place this in a utility or lib file with in your project
+```bash
+npm install model-redis
+```
+
+## Getting Started
+
+`setUpTable([object])` - Function to bind the Redis connection
+to the ORM table. It takes an optional connected redis client object
+or configuration for the Redis module. This will return a `Table` class we
+can use later for our models.
+
+The function returns synchronously, making it compatible with both CommonJS and ESM.
+Redis connection happens in the background, and operations automatically await the connection.
+
+It is recommended you place this in a utility or lib file within your project
 and require it when needed.
 
-The simplest way to use this is to pass nothing to the `setUpTable` function.
-this will create a connected client to Redis using the default settings:
+### CommonJS Usage
+
+The simplest way to use this in CommonJS is to pass nothing to the `setUpTable` function.
+This will create a connected client to Redis using the default settings:
 
 ```javascript
 'use strict';
 
-const {setUpTable} = require('model-redis')
+const {setUpTable} = require('model-redis');
 
 const Table = setUpTable();
 
 module.exports = Table;
 ```
 
+### ESM Usage
+
+For ESM projects, you can still use `await` if preferred (though it's no longer required):
+
+```javascript
+import {setUpTable} from 'model-redis';
+
+const Table = await setUpTable();
+
+export default Table;
+```
+
 You can also pass your own configuration options to the Redis client. See the
 redis [client configuration guide](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md)
 for available options:
@@ -39,12 +72,12 @@ for available options:
 const {setUpTable} = require('model-redis');
 
 const conf = {
-	socket: {
-		host: '10.10.10.10'
-		port: 7676
-	},
-	username: admin,
-	password: hunter42
+    socket: {
+        host: '10.10.10.10',
+        port: 7676
+    },
+    username: 'admin',
+    password: 'hunter42'
 };
 
 const Table = setUpTable({redisConf: conf});
@@ -53,27 +86,28 @@ module.exports = Table;
 ```
 
 It can also take a Redis client object, if you would like to have more control
-or use a custom version on Redis.
+or use a custom version of Redis:
 
 ```javascript
 'use strict';
 
 const {setUpTable} = require('model-redis');
-
 const {createClient} = require('redis');
+
 const client = createClient();
-client.connect();
+await client.connect();
 
 const Table = setUpTable({redisClient: client});
 
 module.exports = Table;
-
 ```
 
-### Prefix key
+**Note:** When passing a custom client, ensure it's connected before passing it to `setUpTable`.
+
+### Prefix Key
 
 At some point, the Redis package removed the option to prefix a string to the
-keys. This functionally has been added back with this package
+keys. This functionality has been added back with this package:
 
 ```javascript
 'use strict';
@@ -81,148 +115,282 @@ keys. This functionally has been added back with this package
 const {setUpTable} = require('model-redis');
 
 const Table = setUpTable({
-	prefix: 'auth_app'
+    prefix: 'auth_app:'
 });
 
 module.exports = Table;
 ```
 
-Once we have have our table object, we can start building using the ORM!
+Once we have our table object, we can start building using the ORM!
 
 ## ORM API
 
 The Table class implements static and bound functions to perform normal ORM
 operations. For the rest of these examples, we will implement a simple user
-backing. This will show some usage and extenabilty:
+backend. This will show some usage and extensibility:
 
-``` javascript
-const Table = require('../utils/redis_model'); // Path to where the 'model-redis module is loaded and configured'
-const {Token, InviteToken} = require('./token');
+```javascript
+const Table = require('../utils/redis_model'); // Path to where the 'model-redis' module is loaded and configured
 const bcrypt = require('bcrypt'); // We will use this for passwords later
 const saltRounds = 10;
 
-class User extends Table{
-	static _key = 'username';
-	static _keyMap = {
-		'created_by': {isRequired: true, type: 'string', min: 3, max: 500},
-		'created_on': {default: function(){return (new Date).getTime()}},
-		'updated_by': {default:"__NONE__", type: 'string',},
-		'updated_on': {default: function(){return (new Date).getTime()}, always: true},
-		'username': {isRequired: true, type: 'string', min: 3, max: 500},
-		'password': {isRequired: true, type: 'string', min: 3, max: 500},
-	};
-
-	static async add(data) {
-		try{
-			data['password'] = await bcrypt.hash(data['password'], saltRounds);
-
-			return await super.add(data);
-		}catch(error){
-			throw error;
-		}
-	}
-
-	async setPassword(data){
-		try{
-			data['password'] = await bcrypt.hash(data['password'], saltRounds);
-
-			return this.update(data);
-		}catch(error){
-			throw error;
-		}
-	}
-
-	static async login(data){
-		try{
-			let user = await User.get(data);
-			let auth = await bcrypt.compare(data.password, user.password);
-
-			if(auth){
-				return user;
-			}else{
-				throw new Error("LogginFailed");
-			}
-		}catch(error){
-			throw new Error("LogginFailed")
-		}
-	};
+class User extends Table {
+    static _key = 'username';
+    static _keyMap = {
+        'created_by': {isRequired: true, type: 'string', min: 3, max: 500},
+        'created_on': {default: function(){return Date.now()}, type: 'number'},
+        'updated_by': {default: "__NONE__", type: 'string'},
+        'updated_on': {default: function(){return Date.now()}, type: 'number', always: true},
+        'username': {isRequired: true, type: 'string', min: 3, max: 500},
+        'password': {isRequired: true, type: 'string', min: 3, max: 500, isPrivate: true},
+        'email': {isRequired: true, type: 'string'}
+    };
+
+    static async create(data) {
+        try {
+            data['password'] = await bcrypt.hash(data['password'], saltRounds);
+            return await super.create(data);
+        } catch(error) {
+            throw error;
+        }
+    }
+
+    async setPassword(newPassword) {
+        try {
+            const hashedPassword = await bcrypt.hash(newPassword, saltRounds);
+            return this.update({password: hashedPassword});
+        } catch(error) {
+            throw error;
+        }
+    }
+
+    static async login(data) {
+        try {
+            let user = await User.get(data.username);
+            let auth = await bcrypt.compare(data.password, user.password);
+
+            if(auth) {
+                return user;
+            } else {
+                throw new Error("LoginFailed");
+            }
+        } catch(error) {
+            throw new Error("LoginFailed");
+        }
+    }
 }
 
 module.exports = {User};
-
 ```
 
-### Table schema
+### Table Schema
 
-The table schema a required aspect of using this module. The schema is defined
-with `_key`, `_indexed` and `_keyMap`
+The table schema is a required aspect of using this module. The schema is defined
+with `_key` and `_keyMap`:
 
 * `static _key` *string* is required and is basically the primary key for this
-	table. It MUST match one of the keys in the `_keyMap` schema
-
-* `static _indexed` *array* is optional list of keys to be indexed. Indexed keys
-can be searched by with the `list()` and `listDetial()` methods.
+    table. It MUST match one of the keys in the `_keyMap` schema
 
 * `static _keyMap` *object* is required and defines the allowed schema for the
-table. Validation will be enforced based on what is defined in the schema.
+    table. Validation will be enforced based on what is defined in the schema.
 
 The `_keyMap` schema is an object where the key is the name of the field and the
 value is an object with the options for that field:
+
 ```javascript
 'username': {isRequired: true, type: 'string', min: 3, max: 500}
-
 ```
 
-#### Field options:
-
-* `type` *string* Required The native type this field will be checked for, valid
-	types are:
-	
-	* `string`
-	* `number` 
-	* `boolean`
-	* `object`
-
-* `isRequired` *boolean* If this is set to true, this must be set when a new
-	entry is created. This has no effect on updates.
-* `default` *field type or function* if nothing is passed, this will be used be
-	used. If a function is placed here, it will be called and its return value
-	used.
-* `always` *boolean* If this is set, the `default` is set, then its value will
-	always be used when calling update. This is useful for setting an updated on
-	field or access count.
-* `min` *number* Used with *string* or *number* type to define the lower limit
-* `max` *number* Used with *string* or *number* type to define the max limit 
+#### Field Options:
+
+* `type` *string* - The native type this field will be checked for. Valid types are:
+    * `string`
+    * `number`
+    * `boolean`
+    * `object`
+
+* `isRequired` *boolean* - If set to true, this must be set when a new
+    entry is created. This has no effect on updates.
+
+* `default` *value or function* - If nothing is passed, this will be used.
+    If a function is placed here, it will be called and its return value used.
+
+* `always` *boolean* - If this is set and `default` is set, then its value will
+    always be used when calling update. This is useful for setting an "updated_on"
+    field or access count.
+
+* `min` *number* - Used with *string* or *number* type to define the lower limit
+
+* `max` *number* - Used with *string* or *number* type to define the max limit
+
+* `isPrivate` *boolean* - If set to true, this field will be excluded from `toJSON()` output.
+    Useful for passwords or sensitive data.
+
+* `model` *string* - For relationships, specify the model name to link to
+
+* `rel` *string* - Relationship type: `'one'` or `'many'`
+
+* `localKey` *string* - For relationships, the local field to use (defaults to `_key`)
+
+* `remoteKey` *string* - For relationships, the remote field to match against
 
 Once we have defined a `_keyMap` schema, the table can be used.
 
-#### Methods
+## Methods
+
+### Static Methods
 
 Static methods are used to query data and create new entries.
 
-* `await add(data)`  Creates and returns a new entry. The passed data object
-	will be validated and a validation error(complete will all the key errors)
-	will be thrown if validation fails. Any key passed in the data object that 
-	is not in the `_keyMap` schema will be dropped.
+* `await create(data)` - Creates and returns a new entry. The passed data object
+    will be validated and a validation error (complete with all the key errors)
+    will be thrown if validation fails. Any key passed in the data object that
+    is not in the `_keyMap` schema will be dropped.
+
+* `await list()` - Returns a list of the primary keys in the table.
+
+* `await listDetail([options], [queryHelper])` - Returns a list of Table instances.
+    Can optionally filter by passing an options object: `{age: 30, active: true}`
 
-* `await list([index_field, [index value]])` Returns a list of the primary keys in
-	 the table. If you pass `index_field` and `index_value`, only those matching
-	 will be returned.
+* `await findall([options])` - Alias for `listDetail()`
 
-* `await listDetial([index_field, [index value]])` same as `list`, but will
-	return a list of Table instances.
+* `await get(pk, [queryHelper])` - Returns a Table instance for the passed primary key.
+    If none is found, a not found error is thrown.
 
-* `await get(pk)` returns a Table instance for the passed object. If none is,
-	found a not found error is thrown
+* `await exists(pk)` - Returns `true` or `false` if the passed PK exists.
 
-* `await exists(pk)` Returns `true` or `false` if the passed PK exists.
+* `register([Model])` - Registers a model in the global registry for relationships.
+
+### Instance Methods
 
 Instances of a Table have the following methods:
 
-* `await update(data)` updates the current instance with the newly passed data
-	and returns a new instance with the updated data. Data validation is also.
+* `await update(data)` - Updates the current instance with the newly passed data
+    and returns the updated instance. Data validation is also enforced.
+
+* `await remove()` - Deletes the current Table instance and returns itself.
+
+* `toJSON()` - Returns a plain JavaScript object representation of the instance.
+    Fields marked with `isPrivate: true` are excluded.
+
+* `toString()` - Returns the primary key value as a string.
+
+All of these methods are extensible so proper business logic can be implemented.
+
+## Relationships
+
+Model Redis supports relationships between models through the model registry system:
+
+```javascript
+const Table = setUpTable();
+
+// Define User model
+class User extends Table {
+    static _key = 'id';
+    static _keyMap = {
+        id: {type: 'string', isRequired: true},
+        name: {type: 'string', isRequired: true},
+        posts: {model: 'Post', rel: 'many', remoteKey: 'userId', localKey: 'id'}
+    };
+}
+
+// Define Post model
+class Post extends Table {
+    static _key = 'id';
+    static _keyMap = {
+        id: {type: 'string', isRequired: true},
+        title: {type: 'string', isRequired: true},
+        userId: {type: 'string', isRequired: true},
+        user: {model: 'User', rel: 'one', localKey: 'userId'}
+    };
+}
+
+// Register models
+User.register();
+Post.register();
+
+// Now relationships will be loaded automatically
+const user = await User.get('user1');
+console.log(user.posts); // Array of Post instances
+
+const post = await Post.get('post1');
+console.log(post.user); // User instance
+```
+
+### Cycle Detection
+
+The QueryHelper class automatically prevents infinite loops in circular relationships:
+
+```javascript
+// User has many Posts, Post belongs to User
+// When loading a User, it loads Posts
+// Each Post tries to load its User (circular)
+// QueryHelper detects this and prevents infinite recursion
+const user = await User.get('user1');
+// user.posts will be loaded, but user.posts[0].user won't recurse
+```
+
+## Error Handling
+
+The module provides custom error types:
+
+* `ObjectValidateError` - Thrown when validation fails, includes array of field errors
+* `EntryNotFound` - Thrown when trying to get a non-existent entry
+* `EntryNameUsed` - Thrown when trying to create an entry with an existing primary key
+
+```javascript
+try {
+    await User.create({username: 'john'}); // Missing required 'email'
+} catch(error) {
+    if(error.name === 'ObjectValidateError') {
+        console.log(error.message); // Array of validation errors
+        console.log(error.status); // 422
+    }
+}
+```
+
+## Testing
+
+The project includes a comprehensive test suite:
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+```
+
+### Test Coverage
+
+- **84.88%** overall coverage
+- **67 tests** (66 passing, 1 skipped)
+- Tests for validation, CRUD operations, filtering, and serialization
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Generate coverage report
+npm run test:coverage
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and pull requests are welcome! Please see the [issues page](https://github.com/wmantly/model-redis/issues) for current bugs and feature requests.
 
-* `await remove()` Deletes the current Table instance and returns the delete
-count, this should be 1.
+## Known Issues
 
-All of these methods are extendable so proper business logic can be implemented.
+- [Issue #3](https://github.com/wmantly/model-redis/issues/3) - Memory leak in relationship test suite (does not affect production usage)

package/index.js

@@ -5,17 +5,21 @@ var client = null
 function setUpTable(obj){
 	obj = obj || {};
 
+	let connectionPromise;
+
 	if(obj.redisClient){
 		client = obj.redisClient;
+		// If a client is provided, assume it's already connected or will be connected externally
+		connectionPromise = Promise.resolve(client);
 	}else{
 		const {createClient} = require('redis');
 		client = createClient(obj.redisConf || {});
-		client.connect();
+		// Connect in background and store the promise
+		connectionPromise = client.connect().then(() => client);
 	}
 
-	// test client connection
-	
-	return table(client, obj.prefix);
+	// Return Table class immediately with connection promise injected
+	return table(client, obj.prefix, connectionPromise);
 }
 
 module.exports = {client, setUpTable};

package/package.json

@@ -1,10 +1,23 @@
 {
   "name": "model-redis",
-  "version": "0.2.1",
-  "description": "Simple ORM model for redis in NodsJS",
+  "version": "0.4.0",
+  "description": "Simple ORM model for Redis in Node.js",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageDirectory": "coverage",
+    "collectCoverageFrom": [
+      "src/**/*.js",
+      "index.js"
+    ],
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ]
   },
   "repository": {
     "type": "git",
@@ -23,5 +36,8 @@
   "homepage": "https://github.com/wmantly/model-redis#readme",
   "dependencies": {
     "redis": "^4.6.10"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
   }
 }

package/src/redis_model.js

@@ -2,237 +2,337 @@
 
 const objValidate = require('./object_validate');
 
+class QueryHelper{
+    history = []
+    constructor(origin){
+        this.origin = origin
+        this.history.push(origin.constructor.name);
+    }
+
+    static isNotCycle(modelName, queryHelper){
+        if(!(queryHelper instanceof this)){
+            return true;  // No queryHelper, can't detect cycles
+        }
+        if(queryHelper.history.includes(modelName)){
+            return false;  // Cycle detected - return false to skip
+        }
+        queryHelper.history.push(modelName);
+        return true;  // No cycle detected - return true to continue
+    }
+}
 
-
-function setUpTable(client, prefix=''){
-
-	function redisPrefix(key){
-		return `${prefix}${key}`;
-	}
-
-	class Table{
-		static _indexed = [];
-
-		constructor(data){
-			for(let key in data){
-				this[key] = data[key];
-			}
-		}
-
-		static async get(index){
-			try{
-
-				if(typeof index === 'object'){
-					index = index[this._key]
-				}
-
-				console.log('get', redisPrefix(`${this.prototype.constructor.name}_${index}`))
-
-				let result = await client.HGETALL(
-					redisPrefix(`${this.prototype.constructor.name}_${index}`)
-				);
-
-				if(Object.keys(result).length === 0){
-					let error = new Error('EntryNotFound');
-					error.name = 'EntryNotFound';
-					error.message = `${this.prototype.constructor.name}:${index} does not exists`;
-					error.status = 404;
-					throw error;
-				}
-
-				// Redis always returns strings, use the keyMap schema to turn them
-				// back to native values.
-				result = objValidate.parseFromString(this._keyMap, result);
-
-				return new this.prototype.constructor(result)
-
-			}catch(error){
-				throw error;
-			}
-
-		}
-
-		static async exists(data){
-			try{
-				await this.get(data);
-
-				return true
-			}catch(error){
-				return false;
-			}
-		}
-
-		static async list(index_key, value){
-			// return a list of all the index keys for this table.
-			try{
-
-
-				console.log('here')
-
-				if(index_key && !this._indexed.includes(index_key)) return [];
-				console.log('here2', redisPrefix(`${this.prototype.constructor.name}_${index_key}_${value}`))
-
-				if(index_key && this._indexed.includes(index_key)){
-					return await client.SMEMBERS(
-						redisPrefix(`${this.prototype.constructor.name}_${index_key}_${value}`)
-					);
-				}
-				console.log('here3', redisPrefix(this.prototype.constructor.name))
-
-				return await client.SMEMBERS(
-					redisPrefix(this.prototype.constructor.name));
-
-			}catch(error){
-				throw error;
-			}
-		}
-
-		static async listDetail(index_key, value){
-			// Return a list of the entries as instances.
-			let out = [];
-
-			for(let entry of await this.list(index_key, value)){
-				out.push(await this.get(entry));
-			}
-
-			return out;
-		}
-
-		static async add(data){
-			// Add a entry to this redis table.
-			try{
-				// Validate the passed data by the keyMap schema.
-
-				data = objValidate.processKeys(this._keyMap, data);
-
-				// Do not allow the caller to overwrite an existing index key,
-				if(data[this._key] && await this.exists(data)){
-					let error = new Error('EntryNameUsed');
-					error.name = 'EntryNameUsed';
-					error.message = `${this.prototype.constructor.name}:${data[this._key]} already exists`;
-					error.status = 409;
-
-					throw error;
-				}
-
-				// Add the key to the members for this redis table
-				await client.SADD(
-					redisPrefix(this.prototype.constructor.name),
-					String(data[this._key])
-				);
-
-				// Create index keys lists
-				for(let index of this._indexed){
-					if(data[index]) await client.SADD(
-						redisPrefix(`${this.prototype.constructor.name}_${index}_${data[index]}`),
-						String(data[this._key]
-					));
-				}
-
-				// Add the values for this entry.
-				for(let key of Object.keys(data)){
-					await client.HSET(
-						redisPrefix(`${this.prototype.constructor.name}_${data[this._key]}`),
-						key, objValidate.parseToString(data[key])
-					);
-				}
-
-				// return the created redis entry as entry instance.
-				return await this.get(data[this._key]);
-			} catch(error){
-				throw error;
-			}
-		}
-
-		async update(data, key){
-			// Update an existing entry.
-			try{
-				// Check to see if entry name changed.
-				if(data[this.constructor._key] && data[this.constructor._key] !== this[this.constructor._key]){
-
-					// Merge the current data into with the updated data 
-					let newData = Object.assign({}, this, data);
-
-					// Remove the updated failed so it doesnt keep it
-					delete newData.updated;
-
-					// Create a new record for the updated entry. If that succeeds,
-					// delete the old recored
-					if(await this.add(newData)) await this.remove();
-
-				}else{
-					// Update what ever fields that where passed.
-
-					// Validate the passed data, ignoring required fields.
-					data = objValidate.processKeys(this.constructor._keyMap, data, true);
-					
-					// Update the index keys
-					for(let index of this.constructor._indexed){
-						if(data[index]){
-							await client.SREM(
-								redisPrefix(`${this.constructor.name}_${index}_${this[index]}`),
-								String(this[this.constructor._key])
-							);
-
-							await client.SADD(
-								redisPrefix(`${this.constructor.name}_${index}_${data[index]}`),
-								String(data[this.constructor._key] || this[this.constructor._key])
-							);
-						}
-
-					}
-					// Loop over the data fields and apply them to redis
-					for(let key of Object.keys(data)){
-						this[key] = data[key];
-						await client.HSET(
-							redisPrefix(`${this.constructor.name}_${this[this.constructor._key]}`),
-							key, data[key]
-						);
-					}
-				}
-
-				return this;
-			
-			} catch(error){
-				// Pass any error to the calling function
-				throw error;
-			}
-		}
-
-		async remove(data){
-			// Remove an entry from this table.
-
-			try{
-				// Remove the index key from the tables members list.
-
-				await client.SREM(
-					redisPrefix(this.constructor.name),
-					this[this.constructor._key]
-				);
-
-				for(let index of this.constructor._indexed){
-					await client.SREM(
-						redisPrefix(`${this.constructor.name}_${index}_${data[value]}`),
-						data[this.constructor._key]
-					);
-				}
-
-				// Remove the entries hash values.
-				let count = await client.DEL(
-					redisPrefix(
-						`${this.constructor.name}_${this[this.constructor._key]}`)
-					);
-
-				// Return the number of removed values to the caller.
-				return count;
-
-			} catch(error) {
-				throw error;
-			}
-		};
-	}
-
-	return Table;
+function setUpTable(client, prefix='', connectionPromise=null){
+
+    function redisPrefix(key){
+        return `${prefix}${key}`;
+    }
+
+    // Helper function to await connection if promise exists
+    async function ensureClientReady(){
+        if(connectionPromise){
+            await connectionPromise;
+        }
+    }
+
+    class Table{
+        static errors = {
+            ObjectValidateError: objValidate.ObjectValidateError,
+            EntryNameUsed: ()=>{
+                let error = new Error('EntryNameUsed');
+                error.name = 'EntryNameUsed';
+                error.message = `${this.prototype.constructor.name}:${data[this._key]} already exists`;
+                error.keys = [{
+                    key: this._key,
+                    message: `${this.prototype.constructor.name}:${data[this._key]} already exists`
+                }]
+                error.status = 409;
+
+                return error;
+            }
+        }
+
+        static redisClient = client;
+
+        static models = {}
+        static register = function(Model){
+            Model = Model || this;
+            this.models[Model.name] = Model;
+        }
+
+        constructor(data){
+            for(let key in data){
+                this[key] = data[key];
+            }
+        }
+
+        static async get(index, queryHelper){
+            try{
+                // Ensure client is connected before proceeding
+                await ensureClientReady();
+
+                if(typeof index === 'object'){
+                    index = index[this._key];
+                }
+
+                let result = await client.HGETALL(
+                    redisPrefix(`${this.prototype.constructor.name}_${index}`)
+                );
+
+                if(!result || !Object.keys(result).length){
+                    let error = new Error('EntryNotFound');
+                    error.name = 'EntryNotFound';
+                    error.message = `${this.prototype.constructor.name}:${index} does not exists`;
+                    error.status = 404;
+                    throw error;
+                }
+
+                // Redis always returns strings, use the keyMap schema to turn them
+                // back to native values.
+                result = objValidate.parseFromString(this._keyMap, result);
+
+                let instance = new this(result);
+                await instance.buildRelations(queryHelper);
+
+                return instance;
+            }catch(error){
+                throw error;
+            }
+        }
+
+        async buildRelations(queryHelper){
+            // Create QueryHelper if not provided
+            if(!queryHelper){
+                queryHelper = new QueryHelper(this);
+            }
+
+            for(let [key, options] of Object.entries(this.constructor._keyMap)){
+                if(options.model){
+                    let remoteModel = this.constructor.models[options.model]
+                    try{
+                        if(!QueryHelper.isNotCycle(remoteModel.name, queryHelper)) continue;
+                        if(options.rel === 'one'){
+                            this[key] = await remoteModel.get(this[key] || this[options.localKey || this.constructor._key] , queryHelper)
+                        }
+                        if(options.rel === 'many'){
+                            this[key] = await remoteModel.listDetail({
+                                [options.remoteKey]: this[options.localKey || this.constructor._key],
+                            }, queryHelper)
+
+                        }
+                    }catch(error){
+                        // Silently ignore relation loading errors (record may not exist)
+                    }
+                }
+            }
+        }
+
+        static async exists(index){
+            // Ensure client is connected before proceeding
+            await ensureClientReady();
+
+            if(typeof index === 'object'){
+                index = index[this._key];
+            }
+
+            return Boolean(await client.SISMEMBER(
+                redisPrefix(this.prototype.constructor.name),
+                index
+            ));
+        }
+
+        static async list(){
+            // return a list of all the index keys for this table.
+            try{
+                // Ensure client is connected before proceeding
+                await ensureClientReady();
+
+                return await client.SMEMBERS(
+                    redisPrefix(this.prototype.constructor.name)
+                );
+
+            }catch(error){
+                throw error;
+            }
+        }
+
+        static async listDetail(options, queryHelper){
+
+            // Return a list of the entries as instances.
+            let out = [];
+
+            for(let entry of await this.list()){
+                let instance = await this.get(entry, arguments[arguments.length - 1]);
+                if(!options) out.push(instance);
+                let matchCount = 0;
+                for(let option in options){
+                    if(instance[option] === options[option] && ++matchCount === Object.keys(options).length){
+                        out.push(instance);
+                        break;
+                    }
+                }
+            }
+
+            return out;
+        }
+
+        static findall(...args){
+            return this.listDetail(...args);
+        }
+
+        static async create(data){
+            // Add a entry to this redis table.
+            try{
+                // Ensure client is connected before proceeding
+                await ensureClientReady();
+
+                // Validate the passed data by the keyMap schema.
+                data = objValidate.processKeys(this._keyMap, data);
+
+                // Do not allow the caller to overwrite an existing index key,
+                if(data[this._key] && await this.exists(data)){
+                    let error = new Error('EntryNameUsed');
+                    error.name = 'EntryNameUsed';
+                    error.message = `${this.prototype.constructor.name}:${data[this._key]} already exists`;
+                    error.keys = [{
+                        key: this._key,
+                        message: `${this.prototype.constructor.name}:${data[this._key]} already exists`
+                    }]
+                    error.status = 409;
+
+                    throw error;
+                }
+
+                // Add the key to the members for this redis table
+                await client.SADD(
+                    redisPrefix(this.prototype.constructor.name),
+                    data[this._key]
+                );
+
+                // Add the values for this entry.
+                for(let key of Object.keys(data)){
+                    if(data[key] === undefined) continue;
+                    await client.HSET(
+                        redisPrefix(`${this.prototype.constructor.name}_${data[this._key]}`),
+                        key,
+                        objValidate.parseToString(data[key])
+                    );
+                }
+
+                // return the created redis entry as entry instance.
+                return await this.get(data[this._key]);
+            } catch(error){
+                throw error;
+            }
+        }
+
+        async update(data){
+            // Update an existing entry.
+            try{
+                // Ensure client is connected before proceeding
+                await ensureClientReady();
+
+                // Validate the passed data, ignoring required fields.
+                data = objValidate.processKeys(this.constructor._keyMap, data, true);
+
+                // Check to see if entry name changed.
+                if(data[this.constructor._key] && data[this.constructor._key] !== this[this.constructor._key]){
+                    // Remove the index key from the tables members list.
+
+                    if(data[this.constructor._key] && await this.constructor.exists(data)){
+                        let error = new Error('EntryNameUsed');
+                        error.name = 'EntryNameUsed';
+                        error.message = `${this.constructor.name}:${data[this.constructor._key]} already exists`;
+                        error.keys = [{
+                            key: this.constructor._key,
+                            message: `${this.constructor.name}:${data[this.constructor._key]} already exists`
+                        }]
+                        error.status = 409;
+
+                        throw error;
+                    }
+
+                    await client.SREM(
+                        redisPrefix(this.constructor.name),
+                        this[this.constructor._key]
+                    );
+
+                    // Add the key to the members for this redis table
+                    await client.SADD(
+                        redisPrefix(this.constructor.name),
+                        data[this.constructor._key]
+                    );
+
+                    await client.RENAME(
+                        redisPrefix(`${this.constructor.name}_${this[this.constructor._key]}`),
+                        redisPrefix(`${this.constructor.name}_${data[this.constructor._key]}`),
+                    );
+
+                }
+                // Update what ever fields that where passed.
+
+                // Loop over the data fields and apply them to redis
+                for(let key of Object.keys(data)){
+                    this[key] = data[key];
+                    await client.HSET(
+                        redisPrefix(`${this.constructor.name}_${this[this.constructor._key]}`),
+                        key, objValidate.parseToString(data[key])
+                    );
+                }
+
+
+                return this;
+
+            } catch(error){
+                // Pass any error to the calling function
+                throw error;
+            }
+        }
+
+        async remove(data){
+            // Remove an entry from this table.
+
+            try{
+                // Ensure client is connected before proceeding
+                await ensureClientReady();
+
+                // Remove the index key from the tables members list.
+                await client.SREM(
+                    redisPrefix(this.constructor.name),
+                    this[this.constructor._key]
+                );
+
+                // Remove the entries hash values.
+                let count = await client.DEL(
+                    redisPrefix(`${this.constructor.name}_${this[this.constructor._key]}`)
+                );
+
+                // Return the number of removed values to the caller.
+                return this;
+
+            } catch(error) {
+                throw error;
+            }
+        };
+
+        toJSON(){
+            let result = {};
+            for (const [key, value] of Object.entries(this)) {
+                if(this.constructor._keyMap[key] && this.constructor._keyMap[key].isPrivate) continue;
+                result[key] = value;
+            }
+
+            return result
+
+            // return JSON.stringify(result);
+        }
+
+        toString(){
+            return this[this.constructor._key];
+        }
+
+    }
+
+    return Table;
 }
 
 module.exports = setUpTable;